feat: integrate new desktop shell and extend backend & ADRs

- Added `meldestelle-desktop` module using JVM/Compose Desktop, registered in `settings.gradle.kts`.
- Integrated new screens and desktop navigation into core: `Veranstaltungen`, `TurnierDetail`, etc.
- Expanded backend with `ExposedFunktionaerRepository` in `officials-infrastructure`.
- Completed ADRs for bounded context mapping (`ADR-0014`) and context map (`ADR-0015`).
- Updated and extended project documentation with session logs and architecture decisions.

Signed-off-by: Stefan Mogeritsch <stefan.mo.co@gmail.com>

backend/services/entries/entries-api/build.gradle.kts

@@ -32,6 +32,7 @@ kotlin {
     commonMain {
       dependencies {
         implementation(libs.kotlinx.serialization.json)
+        implementation(projects.core.coreDomain)
       }
     }
     commonTest {

backend/services/entries/entries-api/src/commonMain/kotlin/at/mocode/entries/api/NennungDtos.kt

@@ -0,0 +1,134 @@
+@file:OptIn(kotlin.uuid.ExperimentalUuidApi::class)
+
+package at.mocode.entries.api
+
+import at.mocode.core.domain.model.NennungsStatusE
+import at.mocode.core.domain.model.StartwunschE
+import at.mocode.core.domain.serialization.UuidSerializer
+import kotlinx.serialization.Serializable
+import kotlin.uuid.Uuid
+
+/**
+ * Vollständige Nennungs-Details (für GET /{id}, POST, PUT, DELETE Responses).
+ */
+@Serializable
+data class NennungDetailDto(
+  @Serializable(with = UuidSerializer::class)
+  val nennungId: Uuid,
+  @Serializable(with = UuidSerializer::class)
+  val abteilungId: Uuid,
+  @Serializable(with = UuidSerializer::class)
+  val bewerbId: Uuid,
+  @Serializable(with = UuidSerializer::class)
+  val turnierId: Uuid,
+  @Serializable(with = UuidSerializer::class)
+  val reiterId: Uuid,
+  @Serializable(with = UuidSerializer::class)
+  val pferdId: Uuid,
+  @Serializable(with = UuidSerializer::class)
+  val zahlerId: Uuid? = null,
+  val status: NennungsStatusE,
+  val startwunsch: StartwunschE,
+  val istNachnennung: Boolean,
+  val nachnenngebuehrErlassen: Boolean,
+  val isNachnenngebuehrFaellig: Boolean,
+  val bemerkungen: String? = null,
+  val createdAt: String,
+  val updatedAt: String
+)
+
+/**
+ * Kompakte Nennungs-Übersicht (für Listen-Endpunkte).
+ */
+@Serializable
+data class NennungSummaryDto(
+  @Serializable(with = UuidSerializer::class)
+  val nennungId: Uuid,
+  @Serializable(with = UuidSerializer::class)
+  val turnierId: Uuid,
+  @Serializable(with = UuidSerializer::class)
+  val bewerbId: Uuid,
+  @Serializable(with = UuidSerializer::class)
+  val abteilungId: Uuid,
+  @Serializable(with = UuidSerializer::class)
+  val reiterId: Uuid,
+  @Serializable(with = UuidSerializer::class)
+  val pferdId: Uuid,
+  val status: NennungsStatusE,
+  val istNachnennung: Boolean,
+  val createdAt: String
+)
+
+/**
+ * Request zum Einreichen einer neuen Nennung (POST /).
+ */
+@Serializable
+data class NennungEinreichenRequest(
+  @Serializable(with = UuidSerializer::class)
+  val abteilungId: Uuid,
+  @Serializable(with = UuidSerializer::class)
+  val bewerbId: Uuid,
+  @Serializable(with = UuidSerializer::class)
+  val turnierId: Uuid,
+  @Serializable(with = UuidSerializer::class)
+  val reiterId: Uuid,
+  @Serializable(with = UuidSerializer::class)
+  val pferdId: Uuid,
+  @Serializable(with = UuidSerializer::class)
+  val zahlerId: Uuid? = null,
+  val startwunsch: StartwunschE = StartwunschE.KEIN_WUNSCH,
+  val istNachnennung: Boolean = false,
+  val bemerkungen: String? = null
+)
+
+/**
+ * Request zum Ändern des Nennungs-Status (PUT /{id}/status).
+ */
+@Serializable
+data class NennungStatusAendernRequest(
+  val neuerStatus: NennungsStatusE,
+  val bemerkungen: String? = null
+)
+
+/**
+ * Request für einen Nennungs-Transfer (POST /{id}/transfer).
+ */
+@Serializable
+data class NennungTransferRequest(
+  @Serializable(with = UuidSerializer::class)
+  val neuerReiterId: Uuid? = null,
+  @Serializable(with = UuidSerializer::class)
+  val neuesPferdId: Uuid? = null,
+  val istNachNennschluss: Boolean = false,
+  val nachnenngebuehrErlassen: Boolean = false,
+  @Serializable(with = UuidSerializer::class)
+  val autorisiertVon: Uuid,
+  val grund: String? = null
+)
+
+/**
+ * Response für einen abgeschlossenen Nennungs-Transfer.
+ */
+@Serializable
+data class NennungsTransferDto(
+  @Serializable(with = UuidSerializer::class)
+  val transferId: Uuid,
+  @Serializable(with = UuidSerializer::class)
+  val ursprungsNennungId: Uuid,
+  @Serializable(with = UuidSerializer::class)
+  val neueNennungId: Uuid,
+  @Serializable(with = UuidSerializer::class)
+  val alterReiterId: Uuid? = null,
+  @Serializable(with = UuidSerializer::class)
+  val neuerReiterId: Uuid? = null,
+  @Serializable(with = UuidSerializer::class)
+  val altesPferdId: Uuid? = null,
+  @Serializable(with = UuidSerializer::class)
+  val neuesPferdId: Uuid? = null,
+  val istNachNennschluss: Boolean,
+  val nachnenngebuehrErlassen: Boolean,
+  @Serializable(with = UuidSerializer::class)
+  val autorisiertVon: Uuid,
+  val grund: String? = null,
+  val createdAt: String
+)

backend/services/entries/entries-domain/build.gradle.kts

@@ -0,0 +1,24 @@
+plugins {
+  alias(libs.plugins.kotlinMultiplatform)
+  alias(libs.plugins.kotlinSerialization)
+}
+kotlin {
+  jvm()
+  sourceSets {
+    commonMain {
+      kotlin.srcDir("src/main/kotlin")
+      dependencies {
+        implementation(projects.core.coreDomain)
+        implementation(projects.core.coreUtils)
+        implementation(libs.kotlinx.datetime)
+        implementation(libs.kotlinx.serialization.json)
+      }
+    }
+    commonTest {
+      kotlin.srcDir("src/test/kotlin")
+      dependencies {
+        implementation(projects.platform.platformTesting)
+      }
+    }
+  }
+}

backend/services/entries/entries-domain/src/main/kotlin/at/mocode/entries/domain/model/DomAbteilung.kt

@@ -0,0 +1,110 @@
+@file:OptIn(kotlin.uuid.ExperimentalUuidApi::class)
+
+package at.mocode.entries.domain.model
+
+import at.mocode.core.domain.model.AbteilungsTeilungsTypE
+import at.mocode.core.domain.serialization.KotlinInstantSerializer
+import at.mocode.core.domain.serialization.UuidSerializer
+import kotlinx.serialization.Serializable
+import kotlin.time.Clock
+import kotlin.time.Instant
+import kotlin.uuid.Uuid
+
+/**
+ * Domain-Modell für eine Abteilung im registration-context.
+ *
+ * Eine Abteilung ist die kleinste startbare Einheit innerhalb eines [DomBewerb]s.
+ * Ein Bewerb kann in mehrere Abteilungen aufgeteilt sein (z.B. Abt. 1: ohne Lizenz,
+ * Abt. 2: mit Lizenz R1). Die Aufteilung erfolgt gemäß ÖTO § 39 und den
+ * spartenspezifischen Bestimmungen.
+ *
+ * @property abteilungId Eindeutige interne ID (UUID).
+ * @property bewerbId Referenz auf den übergeordneten Bewerb (UUID).
+ * @property abteilungsNummer Laufende Nummer der Abteilung innerhalb des Bewerbs (1, 2, 3, ...).
+ * @property bezeichnung Optionale Bezeichnung der Abteilung (z.B. „ohne Lizenz", „R1", „4-jährige").
+ * @property teilungsTyp Kriterium, nach dem diese Abteilung abgegrenzt ist (Lizenz, Pferdealter, ...).
+ * @property teilnehmerkreisBeschreibung Freitext-Beschreibung des Teilnehmerkreises (z.B. „Reiter ohne Lizenz").
+ * @property starterAnzahl Aktuelle Anzahl der zugeordneten Starter (Nennungen).
+ * @property maxStarter Maximale Starter in dieser Abteilung (0 = kein Limit).
+ * @property startzeit Geplante Startzeit als ISO-String (z.B. „09:00").
+ * @property bemerkungen Interne Notizen.
+ * @property createdAt Erstellungszeitpunkt.
+ * @property updatedAt Letzter Änderungszeitpunkt.
+ */
+@Serializable
+data class DomAbteilung(
+  @Serializable(with = UuidSerializer::class)
+  val abteilungId: Uuid = Uuid.random(),
+
+  // Zuordnung
+  @Serializable(with = UuidSerializer::class)
+  val bewerbId: Uuid,
+
+  // Identifikation
+  var abteilungsNummer: Int,
+  var bezeichnung: String? = null,
+
+  // Teilungs-Kriterium
+  var teilungsTyp: AbteilungsTeilungsTypE = AbteilungsTeilungsTypE.KEINE,
+  var teilnehmerkreisBeschreibung: String? = null,
+
+  // Starter
+  var starterAnzahl: Int = 0,
+  var maxStarter: Int = 0,
+
+  // Zeitplanung
+  var startzeit: String? = null,
+
+  // Verwaltung
+  var bemerkungen: String? = null,
+
+  // Audit
+  @Serializable(with = KotlinInstantSerializer::class)
+  val createdAt: Instant = Clock.System.now(),
+  @Serializable(with = KotlinInstantSerializer::class)
+  var updatedAt: Instant = Clock.System.now()
+) {
+  /**
+   * Gibt den Anzeigenamen zurück (z.B. „Abt. 1 – ohne Lizenz").
+   */
+  fun getDisplayName(): String =
+    bezeichnung?.let { "Abt. $abteilungsNummer – $it" } ?: "Abt. $abteilungsNummer"
+
+  /**
+   * Prüft, ob die Abteilung noch freie Startplätze hat.
+   * Gibt true zurück, wenn kein Limit gesetzt ist (maxStarter == 0).
+   */
+  fun hatFreiePlaetze(): Boolean =
+    maxStarter == 0 || starterAnzahl < maxStarter
+
+  /**
+   * Validiert die Abteilung auf Überschreitung des maximalen Starter-Limits (§ 39 Abs. 2).
+   * Gibt Warnungen zurück (kein harter Fehler – Override-Event möglich, ADR-0016).
+   */
+  fun validateStarterLimit(): List<String> {
+    val warnings = mutableListOf<String>()
+
+    // Maximale Abteilungsgröße nach Teilung: > 80 Starter → erneute Teilung verpflichtend (§ 39 Abs. 2)
+    if (starterAnzahl > 80) {
+      warnings.add(
+        "WARN_ABTEILUNG_PFLICHT_TEILUNG_UEBERSCHRITTEN: ${getDisplayName()}, " +
+          "Starter: $starterAnzahl > 80. Erneute Teilung verpflichtend (§ 39 Abs. 2). " +
+          "Override möglich (TBA-Entscheidung)."
+      )
+    }
+
+    if (maxStarter > 0 && starterAnzahl > maxStarter) {
+      warnings.add(
+        "WARN_ABTEILUNG_MAX_STARTER_UEBERSCHRITTEN: ${getDisplayName()}, " +
+          "Starter: $starterAnzahl > Limit $maxStarter. Override möglich (TBA-Entscheidung)."
+      )
+    }
+
+    return warnings
+  }
+
+  /**
+   * Erstellt eine Kopie mit aktualisiertem Zeitstempel.
+   */
+  fun withUpdatedTimestamp(): DomAbteilung = this.copy(updatedAt = Clock.System.now())
+}

backend/services/entries/entries-domain/src/main/kotlin/at/mocode/entries/domain/model/DomBewerb.kt

@@ -0,0 +1,150 @@
+@file:OptIn(kotlin.uuid.ExperimentalUuidApi::class)
+
+package at.mocode.entries.domain.model
+
+import at.mocode.core.domain.model.AbteilungsTeilungsTypE
+import at.mocode.core.domain.model.PruefungsTypE
+import at.mocode.core.domain.model.SparteE
+import at.mocode.core.domain.model.TurnierkategorieE
+import at.mocode.core.domain.serialization.KotlinInstantSerializer
+import at.mocode.core.domain.serialization.UuidSerializer
+import kotlinx.serialization.Serializable
+import kotlin.time.Clock
+import kotlin.time.Instant
+import kotlin.uuid.Uuid
+
+/**
+ * Domain-Modell für einen Bewerb im registration-context.
+ *
+ * Ein Bewerb ist eine einzelne Prüfung innerhalb eines Turniers (z.B. „Stilspringen 90 cm").
+ * Er kann in mehrere [DomAbteilung]en aufgeteilt sein. Die Abteilungs-Warn-Logik basiert
+ * auf den ÖTO-Schwellenwerten (§ 39 A-Teil + spartenspezifische Bestimmungen).
+ *
+ * Aggregate Root des `registration-context` für den Bewerbs-Workflow.
+ *
+ * @property bewerbId Eindeutige interne ID (UUID).
+ * @property turnierId Referenz auf das übergeordnete Turnier (UUID).
+ * @property bewerbNummer Laufende Nummer des Bewerbs innerhalb des Turniers (z.B. 1, 2, 3).
+ * @property bezeichnung Offizielle Bezeichnung des Bewerbs (z.B. „Stilspringen 90 cm").
+ * @property sparte Sportliche Sparte (Springen, Dressur, Vielseitigkeit, ...).
+ * @property turnierkategorie Turnierkategorie (A*, A, B*, B, C, ...).
+ * @property pruefungsTyp Typ der Prüfung – bestimmt den Abteilungs-Schwellenwert (§ 39).
+ * @property hoeheCm Höhe in cm (relevant für Springen und Vielseitigkeit).
+ * @property teilungsTyp Kriterium, nach dem der Bewerb in Abteilungen aufgeteilt wird.
+ * @property maxStarterProAbteilung Maximale Starter pro Abteilung (0 = kein Limit gesetzt).
+ * @property istMeisterschaft Ob es sich um einen Meisterschaftsbewerb handelt (Ausnahme von § 39 Abs. 4).
+ * @property istNachnennungErlaubt Ob Nachnennungen für diesen Bewerb zugelassen sind.
+ * @property bemerkungen Interne Notizen.
+ * @property createdAt Erstellungszeitpunkt.
+ * @property updatedAt Letzter Änderungszeitpunkt.
+ */
+@Serializable
+data class DomBewerb(
+  @Serializable(with = UuidSerializer::class)
+  val bewerbId: Uuid = Uuid.random(),
+
+  // Zuordnung
+  @Serializable(with = UuidSerializer::class)
+  val turnierId: Uuid,
+
+  // Identifikation
+  var bewerbNummer: Int,
+  var bezeichnung: String,
+
+  // Fachliche Klassifikation
+  var sparte: SparteE,
+  var turnierkategorie: TurnierkategorieE,
+  var pruefungsTyp: PruefungsTypE,
+  var hoeheCm: Int? = null,
+
+  // Abteilungs-Konfiguration
+  var teilungsTyp: AbteilungsTeilungsTypE = AbteilungsTeilungsTypE.KEINE,
+  var maxStarterProAbteilung: Int = 0,
+
+  // Flags
+  var istMeisterschaft: Boolean = false,
+  var istNachnennungErlaubt: Boolean = true,
+
+  // Verwaltung
+  var bemerkungen: String? = null,
+
+  // Audit
+  @Serializable(with = KotlinInstantSerializer::class)
+  val createdAt: Instant = Clock.System.now(),
+  @Serializable(with = KotlinInstantSerializer::class)
+  var updatedAt: Instant = Clock.System.now()
+) {
+  /**
+   * Gibt den Anzeigenamen mit Nummer zurück (z.B. „1 – Stilspringen 90 cm").
+   */
+  fun getDisplayName(): String = "$bewerbNummer – $bezeichnung"
+
+  /**
+   * Liefert den Pflicht-Teilungs-Schwellenwert gemäß ÖTO § 39 für diesen Prüfungstyp.
+   * Gibt null zurück, wenn keine Pflicht-Teilung aufgrund der Starterzahl gilt
+   * (strukturelle Teilungen werden separat über [pruefungsTyp] und [teilungsTyp] abgebildet).
+   *
+   * Meisterschaftsbewerbe sind von der Pflicht-Teilung ausgenommen (§ 39 Abs. 4).
+   */
+  fun getPflichtTeilungsSchwellenwert(): Int? {
+    if (istMeisterschaft) return null
+    return when (pruefungsTyp) {
+      PruefungsTypE.STIL_SPRINGEN,
+      PruefungsTypE.SPRINGPFERDE,
+      PruefungsTypE.DRESSURPFERDE -> 30
+
+      PruefungsTypE.VIELSEITIGKEIT -> 40
+      PruefungsTypE.SPRINGEN_UEBRIG -> 80
+      else -> null // Kann-Teilung oder strukturell – kein Starter-Schwellenwert
+    }
+  }
+
+  /**
+   * Gibt den Kann-Teilungs-Schwellenwert zurück (nur für Dressur: > 30 Starter, § 39 Abs. 2).
+   * Gibt null zurück, wenn keine Kann-Teilung gilt.
+   */
+  fun getKannTeilungsSchwellenwert(): Int? {
+    if (istMeisterschaft) return null
+    return when (pruefungsTyp) {
+      PruefungsTypE.DRESSUR -> 30
+      else -> null
+    }
+  }
+
+  /**
+   * Validiert den Bewerb auf Abteilungs-Schwellenwerte anhand der aktuellen Starterzahl.
+   * Gibt Warnungen zurück (kein harter Fehler – Override-Event möglich, ADR-0016).
+   *
+   * @param aktuelleStarterAnzahl Aktuelle Anzahl der Nennungen für diesen Bewerb.
+   */
+  fun validateAbteilungsSchwellenwerte(aktuelleStarterAnzahl: Int): List<String> {
+    val warnings = mutableListOf<String>()
+
+    val pflichtSchwellenwert = getPflichtTeilungsSchwellenwert()
+    if (pflichtSchwellenwert != null && aktuelleStarterAnzahl > pflichtSchwellenwert) {
+      warnings.add(
+        "WARN_ABTEILUNG_PFLICHT_TEILUNG_UEBERSCHRITTEN: Bewerb ${getDisplayName()}, " +
+          "Prüfungstyp $pruefungsTyp, Starter: $aktuelleStarterAnzahl > Schwellenwert $pflichtSchwellenwert. " +
+          "Empfehlung: Teilung nach ${teilungsTyp.name}. Override möglich (TBA-Entscheidung)."
+      )
+    }
+
+    val kannSchwellenwert = getKannTeilungsSchwellenwert()
+    if (kannSchwellenwert != null && aktuelleStarterAnzahl > kannSchwellenwert &&
+      teilungsTyp == AbteilungsTeilungsTypE.KEINE
+    ) {
+      warnings.add(
+        "WARN_ABTEILUNG_KANN_TEILUNG_EMPFOHLEN: Bewerb ${getDisplayName()}, " +
+          "Prüfungstyp $pruefungsTyp, Starter: $aktuelleStarterAnzahl > $kannSchwellenwert. " +
+          "Kann-Teilung empfohlen (§ 39 Abs. 2)."
+      )
+    }
+
+    return warnings
+  }
+
+  /**
+   * Erstellt eine Kopie mit aktualisiertem Zeitstempel.
+   */
+  fun withUpdatedTimestamp(): DomBewerb = this.copy(updatedAt = Clock.System.now())
+}

backend/services/entries/entries-domain/src/main/kotlin/at/mocode/entries/domain/model/DomNennung.kt

@@ -0,0 +1,99 @@
+@file:OptIn(kotlin.uuid.ExperimentalUuidApi::class)
+
+package at.mocode.entries.domain.model
+
+import at.mocode.core.domain.model.NennungsStatusE
+import at.mocode.core.domain.model.StartwunschE
+import at.mocode.core.domain.serialization.KotlinInstantSerializer
+import at.mocode.core.domain.serialization.UuidSerializer
+import kotlinx.serialization.Serializable
+import kotlin.time.Clock
+import kotlin.time.Instant
+import kotlin.uuid.Uuid
+
+/**
+ * Domain model representing a competition entry (Nennung) in the registration-context.
+ *
+ * A Nennung is the binding registration of a Reiter-Pferd-Paar (rider-horse pair)
+ * to a specific Abteilung (the smallest unit for entries and results per ÖTO).
+ *
+ * Key rules (ÖTO / registration-context):
+ * - The Abteilung (not the Bewerb) is the smallest unit for entries.
+ * - A Nennungs-Transfer is NOT a cancellation + re-entry, but a transfer operation.
+ *   Already paid Nenngeld is kept as credit (Guthaben) on the payer's account.
+ * - After Nennschluss, a Nachnenngebühr applies (can be waived by the organizer).
+ * - The system issues WARNINGS only – never hard errors. The TBA has the final say.
+ *
+ * @property nennungId Unique internal identifier (UUID).
+ * @property abteilungId Reference to the Abteilung (smallest entry unit).
+ * @property bewerbId Reference to the parent Bewerb (for display/reporting).
+ * @property turnierId Reference to the Turnier.
+ * @property reiterId Reference to the DomReiter (actor-context).
+ * @property pferdId Reference to the DomPferd (actor-context).
+ * @property zahlerId Reference to the payer (may differ from rider, e.g. club pays).
+ * @property status Current status of this entry.
+ * @property startwunsch Rider's preferred starting position (vorne/hinten).
+ * @property istNachnennung Whether this entry was submitted after Nennschluss.
+ * @property nachnenngebuehrErlassen Whether the organizer waived the late entry fee.
+ * @property bemerkungen Optional notes from the Meldestelle.
+ * @property createdAt Timestamp when this entry was created.
+ * @property updatedAt Timestamp when this entry was last updated.
+ */
+@Serializable
+data class DomNennung(
+  @Serializable(with = UuidSerializer::class)
+  val nennungId: Uuid = Uuid.random(),
+
+  // Competition References
+  @Serializable(with = UuidSerializer::class)
+  val abteilungId: Uuid,
+  @Serializable(with = UuidSerializer::class)
+  val bewerbId: Uuid,
+  @Serializable(with = UuidSerializer::class)
+  val turnierId: Uuid,
+
+  // Actor References (actor-context)
+  @Serializable(with = UuidSerializer::class)
+  val reiterId: Uuid,
+  @Serializable(with = UuidSerializer::class)
+  val pferdId: Uuid,
+
+  // Billing Reference (billing-context)
+  @Serializable(with = UuidSerializer::class)
+  val zahlerId: Uuid? = null,
+
+  // Entry Details
+  val status: NennungsStatusE = NennungsStatusE.EINGEGANGEN,
+  val startwunsch: StartwunschE = StartwunschE.KEIN_WUNSCH,
+
+  // Late Entry (Nachnennung)
+  val istNachnennung: Boolean = false,
+  val nachnenngebuehrErlassen: Boolean = false,
+
+  // Notes
+  val bemerkungen: String? = null,
+
+  // Audit Fields
+  @Serializable(with = KotlinInstantSerializer::class)
+  val createdAt: Instant = Clock.System.now(),
+  @Serializable(with = KotlinInstantSerializer::class)
+  var updatedAt: Instant = Clock.System.now()
+) {
+  /**
+   * Checks if this entry is still active (not withdrawn or cancelled).
+   */
+  fun isAktiv(): Boolean = status !in listOf(
+    NennungsStatusE.ZURUECKGEZOGEN,
+    NennungsStatusE.NICHT_ANGETRETEN
+  )
+
+  /**
+   * Checks if a late entry fee (Nachnenngebühr) is due.
+   */
+  fun isNachnenngebuehrFaellig(): Boolean = istNachnennung && !nachnenngebuehrErlassen
+
+  /**
+   * Creates a copy of this entry with an updated timestamp.
+   */
+  fun withUpdatedTimestamp(): DomNennung = this.copy(updatedAt = Clock.System.now())
+}

backend/services/entries/entries-domain/src/main/kotlin/at/mocode/entries/domain/model/DomNennungsTransfer.kt

@@ -0,0 +1,97 @@
+@file:OptIn(kotlin.uuid.ExperimentalUuidApi::class)
+
+package at.mocode.entries.domain.model
+
+import at.mocode.core.domain.serialization.KotlinInstantSerializer
+import at.mocode.core.domain.serialization.UuidSerializer
+import kotlinx.serialization.Serializable
+import kotlin.time.Clock
+import kotlin.time.Instant
+import kotlin.uuid.Uuid
+
+/**
+ * Domain model representing a transfer operation on an existing entry (Nennungs-Transfer).
+ *
+ * A Nennungs-Transfer is the correct way to change the rider and/or horse on an existing
+ * Nennung. It is explicitly NOT a cancellation + re-entry. Already paid Nenngeld is
+ * retained as credit (Guthaben) on the payer's account in the billing-context.
+ *
+ * This model captures the full audit trail of the transfer: who was replaced by whom,
+ * who authorized it, and whether a Nachnenngebühr applies.
+ *
+ * Key rules (ÖTO / registration-context):
+ * - Transfer = atomic operation on the existing Nennung (status → TRANSFERIERT).
+ * - A new Nennung is created for the new Reiter-Pferd-Paar.
+ * - The original Nennung is closed with status TRANSFERIERT (not deleted).
+ * - Paid Nenngeld is credited to the payer's account, not refunded directly.
+ * - Every transfer is stored as an explicit event (Override-Event if after Nennschluss).
+ *
+ * @property transferId Unique internal identifier (UUID).
+ * @property ursprungsNennungId The original Nennung being transferred.
+ * @property neueNennungId The newly created Nennung after the transfer.
+ * @property alterReiterId Rider ID before the transfer (null if only horse changed).
+ * @property neuerReiterId Rider ID after the transfer (null if only horse changed).
+ * @property altesPferdId Horse ID before the transfer (null if only rider changed).
+ * @property neuesPferdId Horse ID after the transfer (null if only rider changed).
+ * @property istNachNennschluss Whether the transfer occurred after Nennschluss.
+ * @property nachnenngebuehrErlassen Whether the organizer waived the late transfer fee.
+ * @property autorisiertVon UUID of the Meldestelle user who authorized the transfer.
+ * @property grund Reason for the transfer (optional, for audit trail).
+ * @property createdAt Timestamp when this transfer was recorded.
+ */
+@Serializable
+data class DomNennungsTransfer(
+  @Serializable(with = UuidSerializer::class)
+  val transferId: Uuid = Uuid.random(),
+
+  // Linked Entries
+  @Serializable(with = UuidSerializer::class)
+  val ursprungsNennungId: Uuid,
+  @Serializable(with = UuidSerializer::class)
+  val neueNennungId: Uuid,
+
+  // What changed – Rider
+  @Serializable(with = UuidSerializer::class)
+  val alterReiterId: Uuid? = null,
+  @Serializable(with = UuidSerializer::class)
+  val neuerReiterId: Uuid? = null,
+
+  // What changed – Horse
+  @Serializable(with = UuidSerializer::class)
+  val altesPferdId: Uuid? = null,
+  @Serializable(with = UuidSerializer::class)
+  val neuesPferdId: Uuid? = null,
+
+  // Timing & Fees
+  val istNachNennschluss: Boolean = false,
+  val nachnenngebuehrErlassen: Boolean = false,
+
+  // Authorization (Override-Event)
+  @Serializable(with = UuidSerializer::class)
+  val autorisiertVon: Uuid,
+  val grund: String? = null,
+
+  // Audit Fields
+  @Serializable(with = KotlinInstantSerializer::class)
+  val createdAt: Instant = Clock.System.now()
+) {
+  /**
+   * Returns true if the rider was changed in this transfer.
+   */
+  fun isReiterGetauscht(): Boolean = alterReiterId != null && neuerReiterId != null
+
+  /**
+   * Returns true if the horse was changed in this transfer.
+   */
+  fun isPferdGetauscht(): Boolean = altesPferdId != null && neuesPferdId != null
+
+  /**
+   * Returns true if a Nachnenngebühr is due for this transfer.
+   */
+  fun isNachnenngebuehrFaellig(): Boolean = istNachNennschluss && !nachnenngebuehrErlassen
+
+  /**
+   * Validates that the transfer changes at least one of rider or horse.
+   */
+  fun isValid(): Boolean = isReiterGetauscht() || isPferdGetauscht()
+}

backend/services/entries/entries-domain/src/main/kotlin/at/mocode/entries/domain/model/DomStartliste.kt

@@ -0,0 +1,156 @@
+@file:OptIn(kotlin.uuid.ExperimentalUuidApi::class)
+
+package at.mocode.entries.domain.model
+
+import at.mocode.core.domain.model.StartlistenStatusE
+import at.mocode.core.domain.serialization.KotlinInstantSerializer
+import at.mocode.core.domain.serialization.UuidSerializer
+import kotlinx.serialization.Serializable
+import kotlin.time.Clock
+import kotlin.time.Instant
+import kotlin.uuid.Uuid
+
+/**
+ * Domain-Modell für eine Startliste im registration-context.
+ *
+ * Eine Startliste gehört zu einer [DomAbteilung] und enthält die geordnete Liste
+ * der Starter (Nennungen) mit ihren Startnummern. Sie durchläuft einen definierten
+ * Workflow: NICHT_ERSTELLT → ENTWURF → VEROEFFENTLICHT → GESPERRT → ARCHIVIERT.
+ *
+ * @property startlisteId Eindeutige interne ID (UUID).
+ * @property abteilungId Referenz auf die zugehörige Abteilung (UUID).
+ * @property bewerbId Referenz auf den übergeordneten Bewerb (UUID) – Denormalisierung für schnellen Zugriff.
+ * @property turnierId Referenz auf das übergeordnete Turnier (UUID) – Denormalisierung für schnellen Zugriff.
+ * @property status Aktueller Status der Startliste im Workflow.
+ * @property eintraege Geordnete Liste der Startlisteneinträge (Startnummer → Nennung).
+ * @property veroeffentlichtAt Zeitpunkt der Veröffentlichung (null = noch nicht veröffentlicht).
+ * @property gesperrtAt Zeitpunkt der Sperrung (null = noch nicht gesperrt).
+ * @property bemerkungen Interne Notizen.
+ * @property createdAt Erstellungszeitpunkt.
+ * @property updatedAt Letzter Änderungszeitpunkt.
+ */
+@Serializable
+data class DomStartliste(
+  @Serializable(with = UuidSerializer::class)
+  val startlisteId: Uuid = Uuid.random(),
+
+  // Zuordnung
+  @Serializable(with = UuidSerializer::class)
+  val abteilungId: Uuid,
+  @Serializable(with = UuidSerializer::class)
+  val bewerbId: Uuid,
+  @Serializable(with = UuidSerializer::class)
+  val turnierId: Uuid,
+
+  // Status
+  var status: StartlistenStatusE = StartlistenStatusE.NICHT_ERSTELLT,
+
+  // Einträge
+  var eintraege: List<StartlistenEintrag> = emptyList(),
+
+  // Zeitstempel Workflow
+  @Serializable(with = KotlinInstantSerializer::class)
+  var veroeffentlichtAt: Instant? = null,
+  @Serializable(with = KotlinInstantSerializer::class)
+  var gesperrtAt: Instant? = null,
+
+  // Verwaltung
+  var bemerkungen: String? = null,
+
+  // Audit
+  @Serializable(with = KotlinInstantSerializer::class)
+  val createdAt: Instant = Clock.System.now(),
+  @Serializable(with = KotlinInstantSerializer::class)
+  var updatedAt: Instant = Clock.System.now()
+) {
+  /**
+   * Gibt die Anzahl der Starter in dieser Startliste zurück.
+   */
+  fun getStarterAnzahl(): Int = eintraege.size
+
+  /**
+   * Gibt den Eintrag für eine bestimmte Startnummer zurück, oder null.
+   */
+  fun getEintragByStartnummer(startnummer: Int): StartlistenEintrag? =
+    eintraege.find { it.startnummer == startnummer }
+
+  /**
+   * Prüft, ob die Startliste bearbeitbar ist (nur im Status ENTWURF).
+   */
+  fun istBearbeitbar(): Boolean = status == StartlistenStatusE.ENTWURF
+
+  /**
+   * Prüft, ob die Startliste veröffentlicht oder gesperrt ist (für Reiter sichtbar).
+   */
+  fun istSichtbar(): Boolean =
+    status == StartlistenStatusE.VEROEFFENTLICHT || status == StartlistenStatusE.GESPERRT
+
+  /**
+   * Führt den Workflow-Übergang ENTWURF → VEROEFFENTLICHT durch.
+   * Gibt Warnungen zurück, wenn der Übergang nicht möglich ist.
+   */
+  fun veroeffentlichen(): List<String> {
+    val warnings = mutableListOf<String>()
+    if (status != StartlistenStatusE.ENTWURF) {
+      warnings.add(
+        "WARN_STARTLISTE_UNGÜLTIGER_STATUS_ÜBERGANG: Startliste kann nur aus Status " +
+          "ENTWURF veröffentlicht werden. Aktueller Status: $status."
+      )
+      return warnings
+    }
+    if (eintraege.isEmpty()) {
+      warnings.add("WARN_STARTLISTE_LEER: Startliste enthält keine Einträge.")
+    }
+    return warnings
+  }
+
+  /**
+   * Führt den Workflow-Übergang VEROEFFENTLICHT → GESPERRT durch.
+   * Gibt Warnungen zurück, wenn der Übergang nicht möglich ist.
+   */
+  fun sperren(): List<String> {
+    val warnings = mutableListOf<String>()
+    if (status != StartlistenStatusE.VEROEFFENTLICHT) {
+      warnings.add(
+        "WARN_STARTLISTE_UNGÜLTIGER_STATUS_ÜBERGANG: Startliste kann nur aus Status " +
+          "VEROEFFENTLICHT gesperrt werden. Aktueller Status: $status."
+      )
+    }
+    return warnings
+  }
+
+  /**
+   * Erstellt eine Kopie mit aktualisiertem Zeitstempel.
+   */
+  fun withUpdatedTimestamp(): DomStartliste = this.copy(updatedAt = Clock.System.now())
+}
+
+/**
+ * Ein einzelner Eintrag in einer Startliste.
+ *
+ * Verbindet eine Startnummer mit einer Nennung ([DomNennung]).
+ *
+ * @property startnummer Die zugewiesene Startnummer (Kopfnummer gemäß Ubiquitous Language).
+ * @property nennungId Referenz auf die zugehörige Nennung (UUID).
+ * @property reiterName Denormalisierter Reitername für schnelle Anzeige.
+ * @property pferdeName Denormalisierter Pferdename für schnelle Anzeige.
+ * @property startwunsch Optionaler Startwunsch (VORNE, HINTEN, KEIN_WUNSCH).
+ * @property istGestrichen Ob der Starter gestrichen wurde (Abmeldung nach Startlistenerstellung).
+ */
+@Serializable
+data class StartlistenEintrag(
+  var startnummer: Int,
+
+  @Serializable(with = UuidSerializer::class)
+  val nennungId: Uuid,
+
+  // Denormalisierte Felder für schnelle Anzeige
+  var reiterName: String,
+  var pferdeName: String,
+
+  // Startwunsch
+  var startwunsch: String? = null,
+
+  // Status
+  var istGestrichen: Boolean = false
+)

backend/services/entries/entries-domain/src/main/kotlin/at/mocode/entries/domain/repository/NennungRepository.kt

@@ -0,0 +1,88 @@
+@file:OptIn(kotlin.uuid.ExperimentalUuidApi::class)
+
+package at.mocode.entries.domain.repository
+
+import at.mocode.core.domain.model.NennungsStatusE
+import at.mocode.entries.domain.model.DomNennung
+import kotlin.uuid.Uuid
+
+/**
+ * Repository-Interface für DomNennung (Nennung) Domain-Operationen.
+ *
+ * Definiert den Vertrag für Datenzugriffs-Operationen ohne Abhängigkeit
+ * von konkreten Implementierungsdetails (Datenbank, etc.).
+ */
+interface NennungRepository {
+
+  /**
+   * Sucht eine Nennung anhand ihrer eindeutigen ID.
+   */
+  suspend fun findById(id: Uuid): DomNennung?
+
+  /**
+   * Sucht alle Nennungen für einen bestimmten Bewerb.
+   */
+  suspend fun findByBewerbId(bewerbId: Uuid): List<DomNennung>
+
+  /**
+   * Sucht alle Nennungen für eine bestimmte Abteilung.
+   */
+  suspend fun findByAbteilungId(abteilungId: Uuid): List<DomNennung>
+
+  /**
+   * Sucht alle Nennungen für ein bestimmtes Turnier.
+   */
+  suspend fun findByTurnierId(turnierId: Uuid): List<DomNennung>
+
+  /**
+   * Sucht alle Nennungen eines bestimmten Reiters.
+   */
+  suspend fun findByReiterId(reiterId: Uuid): List<DomNennung>
+
+  /**
+   * Sucht alle Nennungen für ein bestimmtes Pferd.
+   */
+  suspend fun findByPferdId(pferdId: Uuid): List<DomNennung>
+
+  /**
+   * Sucht alle Nennungen eines Reiters für ein bestimmtes Turnier.
+   */
+  suspend fun findByReiterIdAndTurnierId(reiterId: Uuid, turnierId: Uuid): List<DomNennung>
+
+  /**
+   * Sucht alle Nennungen mit einem bestimmten Status.
+   */
+  suspend fun findByStatus(status: NennungsStatusE): List<DomNennung>
+
+  /**
+   * Sucht alle Nachnennungen für einen Bewerb.
+   */
+  suspend fun findNachnennungenByBewerbId(bewerbId: Uuid): List<DomNennung>
+
+  /**
+   * Speichert eine Nennung (Insert oder Update).
+   */
+  suspend fun save(nennung: DomNennung): DomNennung
+
+  /**
+   * Löscht eine Nennung anhand ihrer ID.
+   *
+   * @return true wenn gelöscht, false wenn nicht gefunden
+   */
+  suspend fun delete(id: Uuid): Boolean
+
+  /**
+   * Zählt alle Nennungen für einen Bewerb.
+   */
+  suspend fun countByBewerbId(bewerbId: Uuid): Long
+
+  /**
+   * Zählt alle Nennungen für eine Abteilung.
+   */
+  suspend fun countByAbteilungId(abteilungId: Uuid): Long
+
+  /**
+   * Zählt alle Nennungen für ein Turnier mit einem bestimmten Status.
+   */
+  suspend fun countByTurnierIdAndStatus(turnierId: Uuid, status: NennungsStatusE): Long
+}

backend/services/entries/entries-domain/src/main/kotlin/at/mocode/entries/domain/repository/NennungsTransferRepository.kt

@@ -0,0 +1,15 @@
+@file:OptIn(kotlin.uuid.ExperimentalUuidApi::class)
+
+package at.mocode.entries.domain.repository
+
+import at.mocode.entries.domain.model.DomNennungsTransfer
+import kotlin.uuid.Uuid
+
+/**
+ * Repository-Interface für DomNennungsTransfer Domain-Operationen.
+ */
+interface NennungsTransferRepository {
+  suspend fun findById(id: Uuid): DomNennungsTransfer?
+  suspend fun findByUrsprungsNennungId(nennungId: Uuid): List<DomNennungsTransfer>
+  suspend fun save(transfer: DomNennungsTransfer): DomNennungsTransfer
+}

backend/services/entries/entries-service/build.gradle.kts

@@ -14,6 +14,9 @@ dependencies {
   implementation(platform(projects.platform.platformBom))
   implementation(projects.platform.platformDependencies)
   implementation(projects.backend.services.entries.entriesApi)
+  implementation(projects.backend.services.entries.entriesDomain)
+  implementation(projects.core.coreUtils)
+  implementation(projects.core.coreDomain)
   implementation(projects.backend.infrastructure.monitoring.monitoringClient)
   implementation(projects.backend.infrastructure.security)
 
@@ -38,6 +41,10 @@ dependencies {
   implementation(libs.spring.boot.starter.aop)
 
   implementation(libs.springdoc.openapi.starter.webmvc.ui)
+  // Exposed ORM für Datenbankzugriff
+  implementation(libs.exposed.core)
+  implementation(libs.exposed.jdbc)
+  implementation(libs.exposed.kotlin.datetime)
 
   testImplementation(projects.platform.platformTesting)
   testImplementation(libs.bundles.testing.jvm)

backend/services/entries/entries-service/src/main/kotlin/at/mocode/entries/service/NennungController.kt

@@ -0,0 +1,87 @@
+@file:OptIn(kotlin.uuid.ExperimentalUuidApi::class)
+
+package at.mocode.entries.service
+
+import at.mocode.entries.api.*
+import at.mocode.entries.service.usecase.NennungUseCases
+import io.swagger.v3.oas.annotations.Operation
+import io.swagger.v3.oas.annotations.tags.Tag
+import org.springframework.http.HttpStatus
+import org.springframework.web.bind.annotation.*
+import kotlin.uuid.Uuid
+
+/**
+ * REST-Controller für den Nennungs-Workflow (registration-context).
+ *
+ * Basis-URL: /api/v1/registrations/nennungen
+ *
+ * Endpunkte:
+ *   GET    /                          → Liste aller Nennungen (gefiltert)
+ *   GET    /{nennungsId}              → Nennung-Detail
+ *   POST   /                          → Neue Nennung einreichen
+ *   PUT    /{nennungsId}/status       → Status ändern
+ *   DELETE /{nennungsId}              → Nennung zurückziehen
+ *   POST   /{nennungsId}/transfer     → Nennungs-Transfer
+ */
+@RestController
+@RequestMapping("/api/v1/registrations/nennungen")
+@CrossOrigin(
+  origins = ["http://localhost:8080", "http://localhost:8083", "http://localhost:4000"],
+  methods = [RequestMethod.GET, RequestMethod.POST, RequestMethod.PUT, RequestMethod.DELETE, RequestMethod.OPTIONS],
+  allowedHeaders = ["*"],
+  allowCredentials = "true"
+)
+@Tag(name = "Nennungen", description = "Nennungs-Workflow (registration-context)")
+class NennungController(
+  private val useCases: NennungUseCases
+) {
+
+  @GetMapping
+  @Operation(summary = "Nennungen abrufen (gefiltert nach turnierId, bewerbId, abteilungId oder reiterId)")
+  suspend fun getNennungen(
+    @RequestParam(required = false) turnierId: String?,
+    @RequestParam(required = false) bewerbId: String?,
+    @RequestParam(required = false) abteilungId: String?,
+    @RequestParam(required = false) reiterId: String?
+  ): List<NennungSummaryDto> = when {
+    turnierId != null -> useCases.getNennungenByTurnier(Uuid.parse(turnierId))
+    bewerbId != null -> useCases.getNennungenByBewerb(Uuid.parse(bewerbId))
+    abteilungId != null -> useCases.getNennungenByAbteilung(Uuid.parse(abteilungId))
+    reiterId != null -> useCases.getNennungenByReiter(Uuid.parse(reiterId))
+    else -> emptyList()
+  }
+
+  @GetMapping("/{nennungsId}")
+  @Operation(summary = "Nennung-Detail abrufen")
+  suspend fun getNennung(@PathVariable nennungsId: String): NennungDetailDto =
+    useCases.getNennungById(Uuid.parse(nennungsId))
+      ?: throw NoSuchElementException("Nennung nicht gefunden: $nennungsId")
+
+  @PostMapping
+  @ResponseStatus(HttpStatus.CREATED)
+  @Operation(summary = "Neue Nennung einreichen")
+  suspend fun nennungEinreichen(
+    @RequestBody request: NennungEinreichenRequest
+  ): NennungDetailDto = useCases.nennungEinreichen(request)
+
+  @PutMapping("/{nennungsId}/status")
+  @Operation(summary = "Nennungs-Status ändern (z.B. BESTAETIGT, ABGELEHNT)")
+  suspend fun statusAendern(
+    @PathVariable nennungsId: String,
+    @RequestBody request: NennungStatusAendernRequest
+  ): NennungDetailDto = useCases.statusAendern(Uuid.parse(nennungsId), request)
+
+  @DeleteMapping("/{nennungsId}")
+  @Operation(summary = "Nennung zurückziehen (Status → ZURUECKGEZOGEN)")
+  suspend fun nennungZurueckziehen(
+    @PathVariable nennungsId: String
+  ): NennungDetailDto = useCases.nennungZurueckziehen(Uuid.parse(nennungsId))
+
+  @PostMapping("/{nennungsId}/transfer")
+  @ResponseStatus(HttpStatus.CREATED)
+  @Operation(summary = "Nennungs-Transfer durchführen (atomare Operation gemäß ÖTO)")
+  suspend fun nennungTransferieren(
+    @PathVariable nennungsId: String,
+    @RequestBody request: NennungTransferRequest
+  ): NennungsTransferDto = useCases.nennungTransferieren(Uuid.parse(nennungsId), request)
+}

backend/services/entries/entries-service/src/main/kotlin/at/mocode/entries/service/config/EntriesBeansConfiguration.kt

@@ -0,0 +1,24 @@
+package at.mocode.entries.service.config
+
+import at.mocode.entries.domain.repository.NennungRepository
+import at.mocode.entries.domain.repository.NennungsTransferRepository
+import at.mocode.entries.service.persistence.NennungRepositoryImpl
+import at.mocode.entries.service.persistence.NennungsTransferRepositoryImpl
+import org.springframework.context.annotation.Bean
+import org.springframework.context.annotation.Configuration
+
+/**
+ * Spring-Bean-Konfiguration für den Entries Service.
+ *
+ * Registriert die Repository-Implementierungen als Spring-Beans,
+ * damit sie in NennungUseCases per Constructor-Injection verfügbar sind.
+ */
+@Configuration
+class EntriesBeansConfiguration {
+
+  @Bean
+  fun nennungRepository(): NennungRepository = NennungRepositoryImpl()
+
+  @Bean
+  fun nennungsTransferRepository(): NennungsTransferRepository = NennungsTransferRepositoryImpl()
+}

backend/services/entries/entries-service/src/main/kotlin/at/mocode/entries/service/config/EntriesDatabaseConfiguration.kt

@@ -0,0 +1,40 @@
+package at.mocode.entries.service.config
+
+import at.mocode.entries.service.persistence.NennungTable
+import at.mocode.entries.service.persistence.NennungsTransferTable
+import jakarta.annotation.PostConstruct
+import org.jetbrains.exposed.v1.jdbc.SchemaUtils
+import org.jetbrains.exposed.v1.jdbc.transactions.transaction
+import org.slf4j.LoggerFactory
+import org.springframework.context.annotation.Configuration
+import org.springframework.context.annotation.Profile
+
+/**
+ * Datenbank-Konfiguration für den Entries Service.
+ *
+ * Initialisiert das Exposed-Schema für Nennungen und Nennungs-Transfers.
+ * Die DB-Verbindung selbst wird durch den zentralen DataSource-Bean initialisiert.
+ */
+@Configuration
+@Profile("!test")
+class EntriesDatabaseConfiguration {
+
+  private val log = LoggerFactory.getLogger(EntriesDatabaseConfiguration::class.java)
+
+  @PostConstruct
+  fun initializeDatabase() {
+    log.info("Initialisiere Datenbank-Schema für Entries Service...")
+    try {
+      transaction {
+        SchemaUtils.createMissingTablesAndColumns(
+          NennungTable,
+          NennungsTransferTable
+        )
+        log.info("Entries Datenbank-Schema erfolgreich initialisiert")
+      }
+    } catch (e: Exception) {
+      log.error("Fehler beim Initialisieren des Datenbank-Schemas", e)
+      throw e
+    }
+  }
+}

backend/services/entries/entries-service/src/main/kotlin/at/mocode/entries/service/config/EntriesExceptionHandler.kt

@@ -0,0 +1,36 @@
+package at.mocode.entries.service.config
+
+import org.slf4j.LoggerFactory
+import org.springframework.http.HttpStatus
+import org.springframework.http.ProblemDetail
+import org.springframework.web.bind.annotation.ExceptionHandler
+import org.springframework.web.bind.annotation.RestControllerAdvice
+
+/**
+ * Globaler Exception-Handler für den Entries Service.
+ *
+ * Mappt Domain-Exceptions auf HTTP-Statuscodes gemäß RFC 9457 (Problem Details).
+ */
+@RestControllerAdvice
+class EntriesExceptionHandler {
+
+  private val log = LoggerFactory.getLogger(EntriesExceptionHandler::class.java)
+
+  @ExceptionHandler(NoSuchElementException::class)
+  fun handleNotFound(ex: NoSuchElementException): ProblemDetail {
+    log.warn("Ressource nicht gefunden: {}", ex.message)
+    return ProblemDetail.forStatusAndDetail(HttpStatus.NOT_FOUND, ex.message ?: "Nicht gefunden")
+  }
+
+  @ExceptionHandler(IllegalArgumentException::class)
+  fun handleBadRequest(ex: IllegalArgumentException): ProblemDetail {
+    log.warn("Ungültige Anfrage: {}", ex.message)
+    return ProblemDetail.forStatusAndDetail(HttpStatus.BAD_REQUEST, ex.message ?: "Ungültige Anfrage")
+  }
+
+  @ExceptionHandler(IllegalStateException::class)
+  fun handleConflict(ex: IllegalStateException): ProblemDetail {
+    log.warn("Konflikt: {}", ex.message)
+    return ProblemDetail.forStatusAndDetail(HttpStatus.CONFLICT, ex.message ?: "Konflikt")
+  }
+}

backend/services/entries/entries-service/src/main/kotlin/at/mocode/entries/service/persistence/NennungRepositoryImpl.kt

@@ -0,0 +1,154 @@
+@file:OptIn(kotlin.uuid.ExperimentalUuidApi::class)
+
+package at.mocode.entries.service.persistence
+
+import at.mocode.core.domain.model.NennungsStatusE
+import at.mocode.core.domain.model.StartwunschE
+import at.mocode.entries.domain.model.DomNennung
+import at.mocode.entries.domain.repository.NennungRepository
+import org.jetbrains.exposed.v1.core.ResultRow
+import org.jetbrains.exposed.v1.core.and
+import org.jetbrains.exposed.v1.core.eq
+import org.jetbrains.exposed.v1.jdbc.deleteWhere
+import org.jetbrains.exposed.v1.jdbc.insert
+import org.jetbrains.exposed.v1.jdbc.selectAll
+import org.jetbrains.exposed.v1.jdbc.transactions.transaction
+import org.jetbrains.exposed.v1.jdbc.update
+import kotlin.time.Clock
+import kotlin.uuid.Uuid
+import kotlin.uuid.toJavaUuid
+import kotlin.uuid.toKotlinUuid
+
+/**
+ * Exposed-basierte Implementierung des NennungRepository.
+ */
+class NennungRepositoryImpl : NennungRepository {
+
+  private fun rowToNennung(row: ResultRow): DomNennung = DomNennung(
+    nennungId = row[NennungTable.id].toKotlinUuid(),
+    abteilungId = row[NennungTable.abteilungId].toKotlinUuid(),
+    bewerbId = row[NennungTable.bewerbId].toKotlinUuid(),
+    turnierId = row[NennungTable.turnierId].toKotlinUuid(),
+    reiterId = row[NennungTable.reiterId].toKotlinUuid(),
+    pferdId = row[NennungTable.pferdId].toKotlinUuid(),
+    zahlerId = row[NennungTable.zahlerId]?.toKotlinUuid(),
+    status = NennungsStatusE.valueOf(row[NennungTable.status]),
+    startwunsch = StartwunschE.valueOf(row[NennungTable.startwunsch]),
+    istNachnennung = row[NennungTable.istNachnennung],
+    nachnenngebuehrErlassen = row[NennungTable.nachnenngebuehrErlassen],
+    bemerkungen = row[NennungTable.bemerkungen],
+    createdAt = row[NennungTable.createdAt],
+    updatedAt = row[NennungTable.updatedAt]
+  )
+
+  override suspend fun findById(id: Uuid): DomNennung? = transaction {
+    NennungTable.selectAll().where { NennungTable.id eq id.toJavaUuid() }
+      .map(::rowToNennung)
+      .singleOrNull()
+  }
+
+  override suspend fun findByBewerbId(bewerbId: Uuid): List<DomNennung> = transaction {
+    NennungTable.selectAll().where { NennungTable.bewerbId eq bewerbId.toJavaUuid() }
+      .map(::rowToNennung)
+  }
+
+  override suspend fun findByAbteilungId(abteilungId: Uuid): List<DomNennung> = transaction {
+    NennungTable.selectAll().where { NennungTable.abteilungId eq abteilungId.toJavaUuid() }
+      .map(::rowToNennung)
+  }
+
+  override suspend fun findByTurnierId(turnierId: Uuid): List<DomNennung> = transaction {
+    NennungTable.selectAll().where { NennungTable.turnierId eq turnierId.toJavaUuid() }
+      .map(::rowToNennung)
+  }
+
+  override suspend fun findByReiterId(reiterId: Uuid): List<DomNennung> = transaction {
+    NennungTable.selectAll().where { NennungTable.reiterId eq reiterId.toJavaUuid() }
+      .map(::rowToNennung)
+  }
+
+  override suspend fun findByPferdId(pferdId: Uuid): List<DomNennung> = transaction {
+    NennungTable.selectAll().where { NennungTable.pferdId eq pferdId.toJavaUuid() }
+      .map(::rowToNennung)
+  }
+
+  override suspend fun findByReiterIdAndTurnierId(reiterId: Uuid, turnierId: Uuid): List<DomNennung> = transaction {
+    NennungTable.selectAll().where {
+      (NennungTable.reiterId eq reiterId.toJavaUuid()) and
+        (NennungTable.turnierId eq turnierId.toJavaUuid())
+    }.map(::rowToNennung)
+  }
+
+  override suspend fun findByStatus(status: NennungsStatusE): List<DomNennung> = transaction {
+    NennungTable.selectAll().where { NennungTable.status eq status.name }
+      .map(::rowToNennung)
+  }
+
+  override suspend fun findNachnennungenByBewerbId(bewerbId: Uuid): List<DomNennung> = transaction {
+    NennungTable.selectAll().where {
+      (NennungTable.bewerbId eq bewerbId.toJavaUuid()) and
+        (NennungTable.istNachnennung eq true)
+    }.map(::rowToNennung)
+  }
+
+  override suspend fun save(nennung: DomNennung): DomNennung = transaction {
+    val now = Clock.System.now()
+    val existing = NennungTable.selectAll()
+      .where { NennungTable.id eq nennung.nennungId.toJavaUuid() }
+      .singleOrNull()
+    if (existing == null) {
+      NennungTable.insert { stmt ->
+        stmt[id] = nennung.nennungId.toJavaUuid()
+        stmt[abteilungId] = nennung.abteilungId.toJavaUuid()
+        stmt[bewerbId] = nennung.bewerbId.toJavaUuid()
+        stmt[turnierId] = nennung.turnierId.toJavaUuid()
+        stmt[reiterId] = nennung.reiterId.toJavaUuid()
+        stmt[pferdId] = nennung.pferdId.toJavaUuid()
+        stmt[zahlerId] = nennung.zahlerId?.toJavaUuid()
+        stmt[status] = nennung.status.name
+        stmt[startwunsch] = nennung.startwunsch.name
+        stmt[istNachnennung] = nennung.istNachnennung
+        stmt[nachnenngebuehrErlassen] = nennung.nachnenngebuehrErlassen
+        stmt[bemerkungen] = nennung.bemerkungen
+        stmt[createdAt] = nennung.createdAt
+        stmt[updatedAt] = now
+      }
+      nennung.copy(updatedAt = now)
+    } else {
+      NennungTable.update({ NennungTable.id eq nennung.nennungId.toJavaUuid() }) { stmt ->
+        stmt[abteilungId] = nennung.abteilungId.toJavaUuid()
+        stmt[bewerbId] = nennung.bewerbId.toJavaUuid()
+        stmt[turnierId] = nennung.turnierId.toJavaUuid()
+        stmt[reiterId] = nennung.reiterId.toJavaUuid()
+        stmt[pferdId] = nennung.pferdId.toJavaUuid()
+        stmt[zahlerId] = nennung.zahlerId?.toJavaUuid()
+        stmt[status] = nennung.status.name
+        stmt[startwunsch] = nennung.startwunsch.name
+        stmt[istNachnennung] = nennung.istNachnennung
+        stmt[nachnenngebuehrErlassen] = nennung.nachnenngebuehrErlassen
+        stmt[bemerkungen] = nennung.bemerkungen
+        stmt[updatedAt] = now
+      }
+      nennung.copy(updatedAt = now)
+    }
+  }
+
+  override suspend fun delete(id: Uuid): Boolean = transaction {
+    NennungTable.deleteWhere { NennungTable.id eq id.toJavaUuid() } > 0
+  }
+
+  override suspend fun countByBewerbId(bewerbId: Uuid): Long = transaction {
+    NennungTable.selectAll().where { NennungTable.bewerbId eq bewerbId.toJavaUuid() }.count()
+  }
+
+  override suspend fun countByAbteilungId(abteilungId: Uuid): Long = transaction {
+    NennungTable.selectAll().where { NennungTable.abteilungId eq abteilungId.toJavaUuid() }.count()
+  }
+
+  override suspend fun countByTurnierIdAndStatus(turnierId: Uuid, status: NennungsStatusE): Long = transaction {
+    NennungTable.selectAll().where {
+      (NennungTable.turnierId eq turnierId.toJavaUuid()) and
+        (NennungTable.status eq status.name)
+    }.count()
+  }
+}

backend/services/entries/entries-service/src/main/kotlin/at/mocode/entries/service/persistence/NennungTable.kt

@@ -0,0 +1,46 @@
+package at.mocode.entries.service.persistence
+
+import org.jetbrains.exposed.v1.core.Table
+import org.jetbrains.exposed.v1.core.java.javaUUID
+import org.jetbrains.exposed.v1.datetime.timestamp
+
+/**
+ * Exposed-Tabellendefinition für Nennungen (registration-context).
+ */
+object NennungTable : Table("nennungen") {
+  val id = javaUUID("id").autoGenerate()
+
+  // Competition References
+  val abteilungId = javaUUID("abteilung_id")
+  val bewerbId = javaUUID("bewerb_id")
+  val turnierId = javaUUID("turnier_id")
+
+  // Actor References (actor-context)
+  val reiterId = javaUUID("reiter_id")
+  val pferdId = javaUUID("pferd_id")
+
+  // Billing Reference (billing-context)
+  val zahlerId = javaUUID("zahler_id").nullable()
+
+  // Entry Details
+  val status = varchar("status", 50)
+  val startwunsch = varchar("startwunsch", 50)
+  val istNachnennung = bool("ist_nachnennung").default(false)
+  val nachnenngebuehrErlassen = bool("nachnenngebuehr_erlassen").default(false)
+  val bemerkungen = text("bemerkungen").nullable()
+
+  // Audit Fields
+  val createdAt = timestamp("created_at")
+  val updatedAt = timestamp("updated_at")
+
+  override val primaryKey = PrimaryKey(id)
+
+  init {
+    index(false, turnierId)
+    index(false, bewerbId)
+    index(false, abteilungId)
+    index(false, reiterId)
+    index(false, pferdId)
+    index(false, status)
+  }
+}

backend/services/entries/entries-service/src/main/kotlin/at/mocode/entries/service/persistence/NennungsTransferRepositoryImpl.kt

@@ -0,0 +1,67 @@
+@file:OptIn(kotlin.uuid.ExperimentalUuidApi::class)
+
+package at.mocode.entries.service.persistence
+
+import at.mocode.entries.domain.model.DomNennungsTransfer
+import at.mocode.entries.domain.repository.NennungsTransferRepository
+import org.jetbrains.exposed.v1.core.ResultRow
+import org.jetbrains.exposed.v1.core.eq
+import org.jetbrains.exposed.v1.jdbc.insert
+import org.jetbrains.exposed.v1.jdbc.selectAll
+import org.jetbrains.exposed.v1.jdbc.transactions.transaction
+import kotlin.time.Clock
+import kotlin.uuid.Uuid
+import kotlin.uuid.toJavaUuid
+import kotlin.uuid.toKotlinUuid
+
+/**
+ * Exposed-basierte Implementierung des NennungsTransferRepository.
+ */
+class NennungsTransferRepositoryImpl : NennungsTransferRepository {
+
+  private fun rowToTransfer(row: ResultRow): DomNennungsTransfer = DomNennungsTransfer(
+    transferId = row[NennungsTransferTable.id].toKotlinUuid(),
+    ursprungsNennungId = row[NennungsTransferTable.ursprungsNennungId].toKotlinUuid(),
+    neueNennungId = row[NennungsTransferTable.neueNennungId].toKotlinUuid(),
+    alterReiterId = row[NennungsTransferTable.alterReiterId]?.toKotlinUuid(),
+    neuerReiterId = row[NennungsTransferTable.neuerReiterId]?.toKotlinUuid(),
+    altesPferdId = row[NennungsTransferTable.altesPferdId]?.toKotlinUuid(),
+    neuesPferdId = row[NennungsTransferTable.neuesPferdId]?.toKotlinUuid(),
+    istNachNennschluss = row[NennungsTransferTable.istNachNennschluss],
+    nachnenngebuehrErlassen = row[NennungsTransferTable.nachnenngebuehrErlassen],
+    autorisiertVon = row[NennungsTransferTable.autorisiertVon].toKotlinUuid(),
+    grund = row[NennungsTransferTable.grund],
+    createdAt = row[NennungsTransferTable.createdAt]
+  )
+
+  override suspend fun findById(id: Uuid): DomNennungsTransfer? = transaction {
+    NennungsTransferTable.selectAll().where { NennungsTransferTable.id eq id.toJavaUuid() }
+      .map(::rowToTransfer)
+      .singleOrNull()
+  }
+
+  override suspend fun findByUrsprungsNennungId(nennungId: Uuid): List<DomNennungsTransfer> = transaction {
+    NennungsTransferTable.selectAll()
+      .where { NennungsTransferTable.ursprungsNennungId eq nennungId.toJavaUuid() }
+      .map(::rowToTransfer)
+  }
+
+  override suspend fun save(transfer: DomNennungsTransfer): DomNennungsTransfer = transaction {
+    val now = Clock.System.now()
+    NennungsTransferTable.insert { stmt ->
+      stmt[id] = transfer.transferId.toJavaUuid()
+      stmt[ursprungsNennungId] = transfer.ursprungsNennungId.toJavaUuid()
+      stmt[neueNennungId] = transfer.neueNennungId.toJavaUuid()
+      stmt[alterReiterId] = transfer.alterReiterId?.toJavaUuid()
+      stmt[neuerReiterId] = transfer.neuerReiterId?.toJavaUuid()
+      stmt[altesPferdId] = transfer.altesPferdId?.toJavaUuid()
+      stmt[neuesPferdId] = transfer.neuesPferdId?.toJavaUuid()
+      stmt[istNachNennschluss] = transfer.istNachNennschluss
+      stmt[nachnenngebuehrErlassen] = transfer.nachnenngebuehrErlassen
+      stmt[autorisiertVon] = transfer.autorisiertVon.toJavaUuid()
+      stmt[grund] = transfer.grund
+      stmt[createdAt] = now
+    }
+    transfer.copy(createdAt = now)
+  }
+}

backend/services/entries/entries-service/src/main/kotlin/at/mocode/entries/service/persistence/NennungsTransferTable.kt

@@ -0,0 +1,46 @@
+package at.mocode.entries.service.persistence
+
+import org.jetbrains.exposed.v1.core.Table
+import org.jetbrains.exposed.v1.core.java.javaUUID
+import org.jetbrains.exposed.v1.datetime.timestamp
+
+/**
+ * Exposed-Tabellendefinition für Nennungs-Transfers (registration-context).
+ *
+ * Ein Transfer ist KEIN Storno + Neunennung, sondern eine atomare Operation
+ * auf der bestehenden Nennung. Die ursprüngliche Nennung erhält Status TRANSFERIERT.
+ */
+object NennungsTransferTable : Table("nennungs_transfers") {
+  val id = javaUUID("id").autoGenerate()
+
+  // Linked Entries
+  val ursprungsNennungId = javaUUID("ursprungs_nennung_id")
+  val neueNennungId = javaUUID("neue_nennung_id")
+
+  // What changed – Rider
+  val alterReiterId = javaUUID("alter_reiter_id").nullable()
+  val neuerReiterId = javaUUID("neuer_reiter_id").nullable()
+
+  // What changed – Horse
+  val altesPferdId = javaUUID("altes_pferd_id").nullable()
+  val neuesPferdId = javaUUID("neues_pferd_id").nullable()
+
+  // Timing & Fees
+  val istNachNennschluss = bool("ist_nach_nennschluss").default(false)
+  val nachnenngebuehrErlassen = bool("nachnenngebuehr_erlassen").default(false)
+
+  // Authorization (Override-Event)
+  val autorisiertVon = javaUUID("autorisiert_von")
+  val grund = text("grund").nullable()
+
+  // Audit
+  val createdAt = timestamp("created_at")
+
+  override val primaryKey = PrimaryKey(id)
+
+  init {
+    index(false, ursprungsNennungId)
+    index(false, neueNennungId)
+    index(false, autorisiertVon)
+  }
+}

backend/services/entries/entries-service/src/main/kotlin/at/mocode/entries/service/usecase/NennungUseCases.kt

@@ -0,0 +1,222 @@
+@file:OptIn(kotlin.uuid.ExperimentalUuidApi::class)
+
+package at.mocode.entries.service.usecase
+
+import at.mocode.core.domain.model.NennungsStatusE
+import at.mocode.entries.api.*
+import at.mocode.entries.domain.model.DomNennung
+import at.mocode.entries.domain.model.DomNennungsTransfer
+import at.mocode.entries.domain.repository.NennungRepository
+import at.mocode.entries.domain.repository.NennungsTransferRepository
+import org.slf4j.LoggerFactory
+import org.springframework.stereotype.Service
+import kotlin.uuid.Uuid
+
+/**
+ * Use Cases für den Nennungs-Workflow (registration-context).
+ *
+ * Kapselt die fachliche Logik gemäß ÖTO-Regelwerk:
+ * - Warn-Logik statt harter Fehler (TBA hat das letzte Wort)
+ * - Transfer = atomare Operation, kein Storno + Neunennung
+ * - Nachnenngebühr kann vom Veranstalter erlassen werden
+ */
+@Service
+class NennungUseCases(
+  private val nennungRepository: NennungRepository,
+  private val transferRepository: NennungsTransferRepository
+) {
+  private val log = LoggerFactory.getLogger(NennungUseCases::class.java)
+
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+
+  suspend fun getNennungById(id: Uuid): NennungDetailDto? =
+    nennungRepository.findById(id)?.toDetailDto()
+
+  suspend fun getNennungenByTurnier(turnierId: Uuid): List<NennungSummaryDto> =
+    nennungRepository.findByTurnierId(turnierId).map { it.toSummaryDto() }
+
+  suspend fun getNennungenByBewerb(bewerbId: Uuid): List<NennungSummaryDto> =
+    nennungRepository.findByBewerbId(bewerbId).map { it.toSummaryDto() }
+
+  suspend fun getNennungenByAbteilung(abteilungId: Uuid): List<NennungSummaryDto> =
+    nennungRepository.findByAbteilungId(abteilungId).map { it.toSummaryDto() }
+
+  suspend fun getNennungenByReiter(reiterId: Uuid): List<NennungSummaryDto> =
+    nennungRepository.findByReiterId(reiterId).map { it.toSummaryDto() }
+
+  // ---------------------------------------------------------------------------
+  // Commands
+  // ---------------------------------------------------------------------------
+
+  /**
+   * Reicht eine neue Nennung ein (POST).
+   * Gibt eine Warnung aus wenn Nachnennung, aber blockiert nicht.
+   */
+  suspend fun nennungEinreichen(request: NennungEinreichenRequest): NennungDetailDto {
+    if (request.istNachnennung) {
+      log.warn(
+        "NACHNENNUNG eingereicht für Turnier={} Bewerb={} Reiter={}",
+        request.turnierId, request.bewerbId, request.reiterId
+      )
+    }
+    val nennung = DomNennung(
+      abteilungId = request.abteilungId,
+      bewerbId = request.bewerbId,
+      turnierId = request.turnierId,
+      reiterId = request.reiterId,
+      pferdId = request.pferdId,
+      zahlerId = request.zahlerId,
+      startwunsch = request.startwunsch,
+      istNachnennung = request.istNachnennung,
+      bemerkungen = request.bemerkungen
+    )
+    val saved = nennungRepository.save(nennung)
+    log.info("Nennung eingereicht: nennungId={} turnierId={}", saved.nennungId, saved.turnierId)
+    return saved.toDetailDto()
+  }
+
+  /**
+   * Ändert den Status einer Nennung (PUT).
+   */
+  suspend fun statusAendern(nennungId: Uuid, request: NennungStatusAendernRequest): NennungDetailDto {
+    val nennung = nennungRepository.findById(nennungId)
+      ?: throw NoSuchElementException("Nennung nicht gefunden: $nennungId")
+
+    val updated = nennung.copy(
+      status = request.neuerStatus,
+      bemerkungen = request.bemerkungen ?: nennung.bemerkungen
+    ).withUpdatedTimestamp()
+
+    val saved = nennungRepository.save(updated)
+    log.info("Nennungs-Status geändert: nennungId={} status={}", nennungId, request.neuerStatus)
+    return saved.toDetailDto()
+  }
+
+  /**
+   * Zieht eine Nennung zurück (DELETE → Status ZURUECKGEZOGEN).
+   */
+  suspend fun nennungZurueckziehen(nennungId: Uuid): NennungDetailDto {
+    val nennung = nennungRepository.findById(nennungId)
+      ?: throw NoSuchElementException("Nennung nicht gefunden: $nennungId")
+
+    val updated = nennung.copy(status = NennungsStatusE.ZURUECKGEZOGEN).withUpdatedTimestamp()
+    val saved = nennungRepository.save(updated)
+    log.info("Nennung zurückgezogen: nennungId={}", nennungId)
+    return saved.toDetailDto()
+  }
+
+  /**
+   * Führt einen Nennungs-Transfer durch (POST /transfer).
+   *
+   * Atomare Operation gemäß ÖTO:
+   * 1. Ursprungs-Nennung → Status TRANSFERIERT
+   * 2. Neue Nennung für neues Reiter-Pferd-Paar anlegen
+   * 3. Transfer-Record als Audit-Trail speichern
+   */
+  suspend fun nennungTransferieren(nennungId: Uuid, request: NennungTransferRequest): NennungsTransferDto {
+    val ursprung = nennungRepository.findById(nennungId)
+      ?: throw NoSuchElementException("Nennung nicht gefunden: $nennungId")
+
+    if (request.neuerReiterId == null && request.neuesPferdId == null) {
+      throw IllegalArgumentException("Transfer erfordert mindestens eine Änderung (Reiter oder Pferd)")
+    }
+
+    if (request.istNachNennschluss) {
+      log.warn(
+        "Transfer NACH NENNSCHLUSS: nennungId={} autorisiertVon={}",
+        nennungId, request.autorisiertVon
+      )
+    }
+
+    // 1. Ursprungs-Nennung schließen
+    val geschlosseneNennung = ursprung.copy(status = NennungsStatusE.TRANSFERIERT).withUpdatedTimestamp()
+    nennungRepository.save(geschlosseneNennung)
+
+    // 2. Neue Nennung anlegen
+    val neueNennung = DomNennung(
+      abteilungId = ursprung.abteilungId,
+      bewerbId = ursprung.bewerbId,
+      turnierId = ursprung.turnierId,
+      reiterId = request.neuerReiterId ?: ursprung.reiterId,
+      pferdId = request.neuesPferdId ?: ursprung.pferdId,
+      zahlerId = ursprung.zahlerId,
+      startwunsch = ursprung.startwunsch,
+      istNachnennung = request.istNachNennschluss,
+      nachnenngebuehrErlassen = request.nachnenngebuehrErlassen,
+      bemerkungen = ursprung.bemerkungen
+    )
+    val gespeicherteNeueNennung = nennungRepository.save(neueNennung)
+
+    // 3. Transfer-Record speichern
+    val transfer = DomNennungsTransfer(
+      ursprungsNennungId = ursprung.nennungId,
+      neueNennungId = gespeicherteNeueNennung.nennungId,
+      alterReiterId = if (request.neuerReiterId != null) ursprung.reiterId else null,
+      neuerReiterId = request.neuerReiterId,
+      altesPferdId = if (request.neuesPferdId != null) ursprung.pferdId else null,
+      neuesPferdId = request.neuesPferdId,
+      istNachNennschluss = request.istNachNennschluss,
+      nachnenngebuehrErlassen = request.nachnenngebuehrErlassen,
+      autorisiertVon = request.autorisiertVon,
+      grund = request.grund
+    )
+    val gespeicherterTransfer = transferRepository.save(transfer)
+
+    log.info(
+      "Nennungs-Transfer abgeschlossen: ursprung={} neu={} transferId={}",
+      nennungId, gespeicherteNeueNennung.nennungId, gespeicherterTransfer.transferId
+    )
+    return gespeicherterTransfer.toDto()
+  }
+
+  // ---------------------------------------------------------------------------
+  // Mapping Helpers
+  // ---------------------------------------------------------------------------
+
+  private fun DomNennung.toDetailDto() = NennungDetailDto(
+    nennungId = nennungId,
+    abteilungId = abteilungId,
+    bewerbId = bewerbId,
+    turnierId = turnierId,
+    reiterId = reiterId,
+    pferdId = pferdId,
+    zahlerId = zahlerId,
+    status = status,
+    startwunsch = startwunsch,
+    istNachnennung = istNachnennung,
+    nachnenngebuehrErlassen = nachnenngebuehrErlassen,
+    isNachnenngebuehrFaellig = isNachnenngebuehrFaellig(),
+    bemerkungen = bemerkungen,
+    createdAt = createdAt.toString(),
+    updatedAt = updatedAt.toString()
+  )
+
+  private fun DomNennung.toSummaryDto() = NennungSummaryDto(
+    nennungId = nennungId,
+    turnierId = turnierId,
+    bewerbId = bewerbId,
+    abteilungId = abteilungId,
+    reiterId = reiterId,
+    pferdId = pferdId,
+    status = status,
+    istNachnennung = istNachnennung,
+    createdAt = createdAt.toString()
+  )
+
+  private fun DomNennungsTransfer.toDto() = NennungsTransferDto(
+    transferId = transferId,
+    ursprungsNennungId = ursprungsNennungId,
+    neueNennungId = neueNennungId,
+    alterReiterId = alterReiterId,
+    neuerReiterId = neuerReiterId,
+    altesPferdId = altesPferdId,
+    neuesPferdId = neuesPferdId,
+    istNachNennschluss = istNachNennschluss,
+    nachnenngebuehrErlassen = nachnenngebuehrErlassen,
+    autorisiertVon = autorisiertVon,
+    grund = grund,
+    createdAt = createdAt.toString()
+  )
+}