@kreiseck/kasseneck-api 0.30.0 → 0.31.0

package/dist/cjs/kasse/texte.js

@@ -16,8 +16,10 @@
  * auf einer Plattform vorkommen kann.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BELEG_MAIL_FEHLER = exports.FEHLERREGELN = exports.MELDUNGEN = void 0;
+exports.BESCHRIFTUNGEN = exports.STORNO_ZAHLUNG_FEHLER = exports.BELEG_MAIL_FEHLER = exports.FEHLERREGELN = exports.MELDUNGEN = void 0;
 exports.belegMailFehler = belegMailFehler;
+exports.stornoZahlungFehler = stornoZahlungFehler;
+exports.beschriftung = beschriftung;
 exports.meldung = meldung;
 exports.meldungGiltFuer = meldungGiltFuer;
 const MELDUNGEN_ROH = {
@@ -29,16 +31,22 @@ const MELDUNGEN_ROH = {
     'kopplung.code_fehlt': { text: 'Bitte den Kopplungs-Code eingeben.' },
     'kopplung.fehlgeschlagen': { text: 'Die Kopplung ist fehlgeschlagen. Bitte erneut versuchen.' },
     'kopplung.unvollstaendig': { text: 'Die Kopplung ist unvollständig zurückgekommen. Bitte im Panel einen neuen Code erzeugen und noch einmal versuchen.' },
-    'geraet.browser_speicher': { text: 'Dieses Gerät konnte nicht gespeichert werden — der Browser-Speicher steht nicht zur Verfügung. Bitte den privaten Modus verlassen.', nur: ['web'] },
+    'geraet.browser_speicher': { text: 'Dieses Gerät konnte nicht gespeichert werden – der Browser-Speicher steht nicht zur Verfügung. Bitte den privaten Modus verlassen.', nur: ['web'] },
     // --- Anmeldung und Sitzung -----------------------------------------------
     'anmeldung.pin_fehlt': { text: 'Bitte die PIN eingeben.' },
     'anmeldung.fehlgeschlagen': { text: 'Die Anmeldung ist fehlgeschlagen. Bitte erneut versuchen.' },
     'anmeldung.nicht_abgeschlossen': { text: 'Die Anmeldung konnte nicht abgeschlossen werden. Bitte erneut versuchen.' },
-    'anmeldung.wird_abgeschlossen': { text: 'Anmeldung wird gerade abgeschlossen — bitte gleich noch einmal drücken.' },
+    'anmeldung.wird_abgeschlossen': { text: 'Anmeldung wird gerade abgeschlossen – bitte gleich noch einmal drücken.' },
     'sitzung.abgelaufen': { text: 'Die Sitzung ist abgelaufen. Bitte erneut anmelden.' },
-    'sitzung.abgelaufen_ohne_netz': { text: 'Keine Verbindung zum Server — die Sitzung ist abgelaufen. Bitte erneut anmelden.' },
+    'sitzung.abgelaufen_ohne_netz': { text: 'Keine Verbindung zum Server – die Sitzung ist abgelaufen. Bitte erneut anmelden.' },
     'sitzung.keine': { text: 'Keine Sitzung.' },
-    'rechte.nicht_aenderbar': { text: 'Das darfst du nicht ändern — das Recht dafür vergibt der Inhaber im Panel.' },
+    // Die Sperre nach Untaetigkeit kuendigt sich an: der Countdown laeuft in
+    // Sekunden, eine Beruehrung haelt die Schicht offen.
+    'sitzung.meldet_ab': { text: 'Kasse meldet in {sekunden} s ab – Bildschirm berühren, um weiterzuarbeiten.', platzhalter: ['sekunden'] },
+    // Wer die Abmelden-Taste ein zweites Mal drueckt, beendet die Schicht –
+    // der Satz steht in der Rueckfrage, bevor es so weit ist.
+    'abmelden.noch_einmal': { text: 'Noch einmal drücken beendet die Schicht an dieser Kasse.' },
+    'rechte.nicht_aenderbar': { text: 'Das darfst du nicht ändern – das Recht dafür vergibt der Inhaber im Panel.' },
     // --- Verkauf und Positionen ----------------------------------------------
     'kasse.laden_fehlgeschlagen': { text: 'Die Kasse konnte nicht geladen werden.' },
     'artikel.laden_fehlgeschlagen': { text: 'Die Artikel konnten nicht geladen werden.' },
@@ -46,30 +54,53 @@ const MELDUNGEN_ROH = {
     'artikel.keine_gefunden': { text: 'Keine Artikel gefunden.' },
     'artikel.steuersatz_unbekannt': { text: '„{name}“ hat einen Steuersatz, den die Kasse nicht kennt.', platzhalter: ['name'] },
     'position.betrag_fehlt': { text: 'Bitte einen Betrag eingeben.' },
-    'position.bezeichnung_fehlt': { text: 'Bitte eine Bezeichnung eingeben — sie steht am Beleg.' },
+    'position.bezeichnung_fehlt': { text: 'Bitte eine Bezeichnung eingeben – sie steht am Beleg.' },
     'rabatt.prozent_ungueltig': { text: 'Bitte einen Prozentwert zwischen 0,1 und 100 eingeben.' },
+    // --- Kassieren -----------------------------------------------------------
+    // Der Grund ueber dem Knopf, solange der Beleg nicht abgeschlossen werden kann.
+    'kassieren.nichts_erfasst': { text: 'Noch nichts erfasst – bitte zuerst eine Position aufnehmen.' },
+    'kassieren.gegeben_fehlt': { text: 'Erst eintippen, was der Gast gibt – der Rückgeld-Rechner ist an.' },
+    'kassieren.gegeben_zu_wenig': { text: 'Gegeben ist weniger als der Betrag.' },
+    // Lebenszyklus der Kasse (ausser Betrieb, Signatureinheit …): der Grund
+    // kommt vom Server bzw. aus dem Kassenstand und steht hinter dem Doppelpunkt.
+    'kassieren.gesperrt': { text: 'Kassieren gesperrt: {grund}', platzhalter: ['grund'] },
+    // Keine gesetzliche Obergrenze – steuerfrei ist aber nur ortsuebliches
+    // Trinkgeld (§ 3 Abs 1 Z 16a EStG). Eine Warnung, keine Sperre.
+    'trinkgeld.ueber_haelfte': { text: 'Über 50 % Trinkgeld – wirklich? Steuerfrei ist nur ortsübliches Trinkgeld.' },
     // --- Abschluss -----------------------------------------------------------
     'abschluss.fehlgeschlagen': { text: 'Der Abschluss ist fehlgeschlagen.' },
-    'abschluss.unklar': { text: 'Unklar, ob der Beleg entstanden ist — die Antwort kam nicht an. Bitte nicht noch einmal abschließen: der Beleg kann bereits erstellt und signiert sein. Im Panel unter „Belege“ nachsehen; nur wenn er dort fehlt, den Verkauf erneut abschließen.' },
+    'abschluss.unklar': { text: 'Unklar, ob der Beleg entstanden ist – die Antwort kam nicht an. Bitte nicht noch einmal abschließen: der Beleg kann bereits erstellt und signiert sein. Im Panel unter „Belege“ nachsehen; nur wenn er dort fehlt, den Verkauf erneut abschließen.' },
     'abschluss.nullbeleg_fehlgeschlagen': { text: 'Der Nullbeleg konnte nicht erstellt werden.' },
     'abschluss.signatur_ausgefallen': { text: 'Die Signatureinheit hat nicht geantwortet. Der Beleg ist gültig und trägt den Vermerk „Sicherheitseinrichtung ausgefallen“.' },
+    // Erledigen darf nur bestaetigen, was am Server auch wirklich steht – sonst
+    // gilt ein Betrag als abgehakt, zu dem es nie einen Beleg gab.
+    'abschluss.erledigen_frage': { text: 'Nur erledigen, wenn der Beleg in der Belegliste steht – sonst bleiben {betrag} ohne Beleg. Bitte zuerst unter „Belege“ nachsehen.', platzhalter: ['betrag'] },
     // --- Kartenzahlung -------------------------------------------------------
     'kartenzahlung.nicht_moeglich': { text: 'Kartenzahlung nicht möglich.' },
     'kartenzahlung.nicht_zustande': { text: 'Die Kartenzahlung ist nicht zustande gekommen.' },
     'kartenzahlung.nicht_gestartet': { text: 'Kartenzahlung nicht gestartet: {grund}', platzhalter: ['grund'] },
-    'kartenzahlung.unklar': { text: 'Unklar, ob die Kartenzahlung durchgegangen ist — die Verbindung zum Terminal riss ab. Bitte am Terminal-Beleg nachsehen, BEVOR neu kassiert wird: die Karte kann belastet sein.' },
+    'kartenzahlung.unklar': { text: 'Unklar, ob die Kartenzahlung durchgegangen ist – die Verbindung zum Terminal riss ab. Bitte am Terminal-Beleg nachsehen, BEVOR neu kassiert wird: die Karte kann belastet sein.' },
     // Die Kennung ist der einzige Anker, um die Zahlung am Terminal-Beleg wiederzufinden — liegt sie vor, gilt dieser Satz statt kartenzahlung.unklar.
-    'kartenzahlung.unklar_mit_kennung': { text: 'Unklar, ob die Kartenzahlung durchgegangen ist — die Verbindung zum Terminal riss ab. Bitte am Terminal-Beleg nachsehen, BEVOR neu kassiert wird: die Karte kann belastet sein. Kennung der Zahlung: {kennung}.', platzhalter: ['kennung'] },
+    'kartenzahlung.unklar_mit_kennung': { text: 'Unklar, ob die Kartenzahlung durchgegangen ist – die Verbindung zum Terminal riss ab. Bitte am Terminal-Beleg nachsehen, BEVOR neu kassiert wird: die Karte kann belastet sein. Kennung der Zahlung: {kennung}.', platzhalter: ['kennung'] },
     'kartenzahlung.wartet_auf_terminal': { text: 'Bitte am Terminal fortfahren …' },
+    // Das Kartenfenster des Terminals ist abgelaufen: es bricht selbst ab, die
+    // Kasse muss nichts tun.
+    'kartenzahlung.terminal_bricht_ab': { text: 'Das Terminal bricht gleich von selbst ab …' },
     // Ein geglücktes Kartenergebnis ohne Beleg ist der teuerste Zustand am Tresen:
     // wer hier erneut kassiert, belastet die Karte ein zweites Mal. Beide Sätze
     // nennen deshalb Betrag UND Kennung — nur damit findet der Kassier die Zahlung
     // am Terminal-Beleg wieder — und keiner rät zum Wiederholen.
-    'kartenzahlung.karte_gebucht_beleg_offen': { text: 'Die Karte ist bereits mit {betrag} belastet (Kennung {kennung}) — der Beleg dazu fehlt noch. Bitte jetzt den Beleg erstellen und nicht erneut kassieren.', platzhalter: ['betrag', 'kennung'] },
+    'kartenzahlung.karte_gebucht_beleg_offen': { text: 'Die Karte ist bereits mit {betrag} belastet (Kennung {kennung}) – der Beleg dazu fehlt noch. Bitte jetzt den Beleg erstellen und nicht erneut kassieren.', platzhalter: ['betrag', 'kennung'] },
     'kartenzahlung.karte_gebucht_korb_geaendert': { text: 'Es gibt eine gebuchte Kartenzahlung über {betrag} (Kennung {kennung}), aber der Korb hat sich seither geändert. Bitte zuerst entscheiden: den Beleg zur gebuchten Zahlung erstellen oder die Zahlung am Terminal stornieren und hier verwerfen.', platzhalter: ['betrag', 'kennung'] },
-    'kartenzahlung.connect_nicht_verbunden': { text: 'Kartenzahlung nicht möglich: Kasseneck Connect ist nicht verbunden — Einstellungen → Kasseneck Connect.', nur: ['web'] },
-    'terminal.keines_gefunden': { text: 'Kein Hobex-Terminal gefunden — ist es eingeschaltet und im selben Netz wie dieser Rechner?', nur: ['web'] },
-    'terminal.nicht_bereit': { text: 'Terminal antwortet, ist aber nicht betriebsbereit: {antwort} — TID prüfen.', platzhalter: ['antwort'], nur: ['web'] },
+    'kartenzahlung.connect_nicht_verbunden': { text: 'Kartenzahlung nicht möglich: Kasseneck Connect ist nicht verbunden – Einstellungen → Kasseneck Connect.', nur: ['web'] },
+    // Solange die Karte belastet ist, darf am Korb nichts mehr veraendert werden –
+    // sonst passt der Beleg nicht mehr zum Betrag, der schon abgebucht ist.
+    'kartenzahlung.korb_gesperrt_karte_belastet': { text: 'Die Karte ist bereits belastet – Warenkorb, Rabatt und Trinkgeld bleiben gesperrt, bis der Beleg entsteht oder die Karte zurückerstattet ist.' },
+    // Entkoppeln trennt das Geraet vom Konto, nicht die gebuchte Kartenzahlung
+    // vom Terminal – die muss weiterhin von Hand storniert werden.
+    'kartenzahlung.entkoppeln_karte_belastet': { text: 'Auf diesem Gerät liegt noch eine gebuchte Kartenzahlung ohne Beleg – sie muss von Hand am Terminal zurückerstattet werden (Betrag siehe unten).' },
+    'terminal.keines_gefunden': { text: 'Kein Hobex-Terminal gefunden – ist es eingeschaltet und im selben Netz wie dieser Rechner?', nur: ['web'] },
+    'terminal.nicht_bereit': { text: 'Terminal antwortet, ist aber nicht betriebsbereit: {antwort} – TID prüfen.', platzhalter: ['antwort'], nur: ['web'] },
     'gptom.app_fehlt': { text: 'Die GP-Tom-App ist auf diesem Gerät nicht da.', nur: ['app'] },
     'gptom.suche_fehlgeschlagen': { text: 'GP Tom: Suche nach der App fehlgeschlagen: {grund}', platzhalter: ['grund'], nur: ['app'] },
     'gptom.zahlung_fehlgeschlagen': { text: 'GP Tom: Zahlung fehlgeschlagen: {grund}', platzhalter: ['grund'], nur: ['app'] },
@@ -80,13 +111,13 @@ const MELDUNGEN_ROH = {
     // liegt einer vor, gilt die Fassung mit Code.
     'gptom.abgelehnt': { text: 'Das Terminal hat die Zahlung abgelehnt.', nur: ['app'] },
     'gptom.abgelehnt_mit_code': { text: 'Das Terminal hat die Zahlung abgelehnt ({code}).', platzhalter: ['code'], nur: ['app'] },
-    'gptom.nicht_geoeffnet': { text: 'GP Tom ließ sich nicht öffnen — bitte die GP-Tom-App prüfen und erneut versuchen.', nur: ['app'] },
+    'gptom.nicht_geoeffnet': { text: 'GP Tom ließ sich nicht öffnen – bitte die GP-Tom-App prüfen und erneut versuchen.', nur: ['app'] },
     // Frist abgelaufen ist kein Abbruch: die Karte kann belastet sein, nur die
     // Antwort blieb aus. Deshalb derselbe Ton wie kartenzahlung.unklar.
-    'gptom.zeit_abgelaufen': { text: 'Das Terminal hat in der Frist nicht geantwortet — die Karte kann belastet sein. Bitte am Terminal-Beleg nachsehen, BEVOR neu kassiert wird.', nur: ['app'] },
-    'gptom.zeit_abgelaufen_mit_kennung': { text: 'Das Terminal hat in der Frist nicht geantwortet — die Karte kann belastet sein. Bitte am Terminal-Beleg nachsehen, BEVOR neu kassiert wird. Kennung der Zahlung: {kennung}.', platzhalter: ['kennung'], nur: ['app'] },
+    'gptom.zeit_abgelaufen': { text: 'Das Terminal hat in der Frist nicht geantwortet – die Karte kann belastet sein. Bitte am Terminal-Beleg nachsehen, BEVOR neu kassiert wird.', nur: ['app'] },
+    'gptom.zeit_abgelaufen_mit_kennung': { text: 'Das Terminal hat in der Frist nicht geantwortet – die Karte kann belastet sein. Bitte am Terminal-Beleg nachsehen, BEVOR neu kassiert wird. Kennung der Zahlung: {kennung}.', platzhalter: ['kennung'], nur: ['app'] },
     // --- Terminal-Protokoll --------------------------------------------------
-    'protokoll.leer': { text: 'Noch keine Einträge — das Protokoll füllt sich mit der ersten Kartenzahlung.' },
+    'protokoll.leer': { text: 'Noch keine Einträge – das Protokoll füllt sich mit der ersten Kartenzahlung.' },
     'protokoll.kopiert': { text: 'Das Protokoll liegt in der Zwischenablage.' },
     // --- Belege und Storno ---------------------------------------------------
     'belege.laden_fehlgeschlagen': { text: 'Die Belege konnten nicht geladen werden.' },
@@ -96,6 +127,62 @@ const MELDUNGEN_ROH = {
     'storno.fehlgeschlagen': { text: 'Das Storno ist fehlgeschlagen.' },
     'storno.grund_fehlt': { text: 'Bitte einen Grund wählen.' },
     'storno.position_fehlt': { text: 'Bitte mindestens eine Position wählen.' },
+    // Storno eines Belegs mit mehreren Zahlungen: je Zahlung wird zurückgegeben,
+    // und der Server prueft jede Rueckgabe gegen den Rest ihrer Zahlung. Welcher
+    // Code welchen Satz bekommt, steht in STORNO_ZAHLUNG_FEHLER.
+    'storno.zahlungen_fehlen': { text: 'Dieser Beleg wurde in mehreren Zahlungen bezahlt – bitte angeben, wie zurückgegeben wird.' },
+    'storno.rueckgabe_zu_hoch': { text: 'Eine Rückgabe ist höher als der Rest ihrer Zahlung – bitte die Beträge prüfen.' },
+    'storno.rueckgabe_ohne_bezug': { text: 'Eine Rückgabe nennt keine Zahlung des Belegs – bitte das Storno neu beginnen.' },
+    'storno.rueckgabe_bezug_unbekannt': { text: 'Eine Rückgabe nennt eine Zahlung, die es am Beleg nicht gibt – bitte das Storno neu beginnen.' },
+    // Die Antwort kam, aber der Ausgang ist offen: der Storno-Beleg kann schon
+    // signiert sein. Wer jetzt noch einmal storniert, storniert womoeglich doppelt.
+    'storno.ergebnis_unklar': { text: 'Unklar, ob das Storno entstanden ist – es kann bereits signiert sein. Bitte nicht erneut stornieren, sondern die Belegliste in ein paar Minuten neu laden.' },
+    'storno.summe_passt_nicht': { text: 'Die Rückgaben ergeben nicht den Betrag des Stornos – bitte die Beträge prüfen.' },
+    // Storno eines Belegs mit mehreren Zahlungen: Karten gehen VON HAND am
+    // Terminal zurueck, und zwar erst NACH dem gebuchten Storno -- vorher
+    // fliesst kein Geld. Darunter steht die Liste der Karten zum Abhaken; der
+    // Satz passt fuer eine oder mehrere Karten, mit oder ohne Anbindung.
+    'storno.karten_gutschreiben': { text: 'Das Storno ist gebucht – bitte jede Karte unten am Terminal gutschreiben und abhaken.' },
+    // Wie storno.ergebnis_unklar, nur enthielt die Rueckgabe Karten: bevor
+    // klar ist, ob das Storno steht, darf keine Gutschrift laufen -- sonst geht
+    // Geld zurueck ohne Storno-Beleg.
+    'storno.ergebnis_unklar_karten': { text: 'Unklar, ob das Storno entstanden ist – es kann bereits signiert sein. Bitte nicht erneut stornieren und noch keine Karte gutschreiben, sondern die Belegliste in ein paar Minuten neu laden. Steht das Storno dort, die Karten laut Storno-Beleg am Terminal gutschreiben.' },
+    // Die Liste der Karten nach dem gebuchten Storno wird geschlossen, obwohl
+    // nicht jede Karte abgehakt ist: einmal nachfragen -- eine vergessene
+    // Gutschrift faellt sonst erst dem Gast auf.
+    'storno.karten_nicht_abgehakt': { text: 'Noch ist nicht jede Karte abgehakt – bitte jede am Terminal gutschreiben. Ist das schon geschehen, zum Schließen noch einmal drücken.' },
+    // --- Getrennt zahlen -----------------------------------------------------
+    // Ein Tisch zahlt in Teilen, ein Beleg fuer alles. Das Teure ist eine schon
+    // belastete Karte: jeder Satz, der sie betrifft, nennt den Betrag, und keiner
+    // raet dazu, noch einmal zu kassieren.
+    'getrennt.einstellung_hinweis': { text: 'Ein Tisch zahlt in Teilen: jede Zahlung bar oder mit Karte, mit eigenem Trinkgeld – am Ende ein Beleg für alles.' },
+    'getrennt.betrag_ueber_offen': { text: 'Der Betrag ist höher als offen – höchstens {betrag}.', platzhalter: ['betrag'] },
+    'getrennt.trinkgeld_ueber_betrag': { text: 'Das Trinkgeld ist höher als der Betrag dieser Zahlung.' },
+    'getrennt.gegeben_zu_wenig': { text: 'Gegeben ist weniger als der Betrag dieser Zahlung.' },
+    'getrennt.noch_offen': { text: 'Es sind noch {betrag} offen – abschließen geht erst, wenn alles kassiert ist.', platzhalter: ['betrag'] },
+    'getrennt.summe_passt_nicht': { text: 'Die Zahlungen ergeben nicht den Betrag des Belegs – bitte die Liste prüfen.' },
+    'getrennt.korb_gesperrt': { text: 'Der Warenkorb ist gesperrt, solange Zahlungen kassiert sind – erst abschließen oder die Zahlungen entfernen.' },
+    'getrennt.wechsel_gesperrt': { text: 'Zurück zu Bar oder Karte geht erst, wenn keine Zahlung mehr kassiert ist.' },
+    'getrennt.bar_zurueckgeben': { text: 'Bitte {betrag} Bargeld an den Gast zurückgeben.', platzhalter: ['betrag'] },
+    'getrennt.karte_zurueckbuchen_laeuft': { text: 'Die Kartenzahlung über {betrag} wird am Terminal zurückgebucht …', platzhalter: ['betrag'] },
+    'getrennt.karte_zurueckgebucht': { text: 'Die Kartenzahlung über {betrag} ist am Terminal zurückgebucht.', platzhalter: ['betrag'] },
+    'getrennt.karte_zurueckbuchen_fehlgeschlagen': { text: 'Die Kartenzahlung über {betrag} (Kennung {kennung}) ließ sich nicht zurückbuchen – sie bleibt in der Liste. Bitte am Terminal-Beleg nachsehen und erneut versuchen.', platzhalter: ['betrag', 'kennung'] },
+    'getrennt.karte_zurueckbuchen_unklar': { text: 'Unklar, ob die Rückbuchung über {betrag} (Kennung {kennung}) durchgegangen ist – die Zahlung bleibt in der Liste. Bitte am Terminal-Beleg nachsehen, BEVOR erneut zurückgebucht wird.', platzhalter: ['betrag', 'kennung'] },
+    // Das Terminal meldet eine Gutschrift, die hier noch als offene Ruecknahme
+    // steht – ein zweites Zurueckbuchen waere die doppelte Rueckgabe.
+    'getrennt.karte_bereits_zurueckgebucht': { text: 'Das Terminal meldet, dass die Kartenzahlung über {betrag} bereits gutgeschrieben wurde (Kennung {kennung}) – bitte am Terminal-Beleg prüfen und nicht erneut zurückbuchen.', platzhalter: ['betrag', 'kennung'] },
+    'getrennt.extern_zurueckbuchen': { text: 'Diese Karte ist nicht an die Kasse angebunden. Bitte {betrag} jetzt am Terminal zurückbuchen und danach bestätigen.', platzhalter: ['betrag'] },
+    'getrennt.sitzung_offen': { text: 'Eine getrennte Zahlung ist nicht abgeschlossen, {betrag} sind schon kassiert. Bitte weiter kassieren oder alles zurückbuchen.', platzhalter: ['betrag'] },
+    'getrennt.sitzung_unlesbar': { text: 'Eine gespeicherte getrennte Zahlung auf diesem Gerät ließ sich nicht lesen – bitte prüfen, ob schon Karten belastet wurden (Kasseneck-Panel oder Terminal), und offene Beträge von Hand ausgleichen.' },
+    'getrennt.ablage_fehlgeschlagen': { text: 'Die getrennte Zahlung ließ sich auf diesem Gerät nicht speichern – bitte die Kasse bis zum Abschluss dieses Belegs nicht neu laden, sonst stehen belastete Karten womöglich nicht mehr in der Liste.' },
+    'getrennt.zu_viele_zahlungen': { text: 'Ein Beleg lässt höchstens 20 Zahlungen zu.' },
+    'getrennt.entkoppeln_offene_karten': { text: 'Auf diesem Gerät ist noch eine getrennte Zahlung mit belasteten Karten offen – sie müssen von Hand am Terminal zurückgebucht werden (Beträge siehe unten).' },
+    'getrennt.positionen_gesperrt': { text: 'Nach Positionen geht nicht mehr – eine Zahlung ist schon als Betrag kassiert.' },
+    'getrennt.positionen_waehlen': { text: 'Bitte zuerst antippen, was dieser Gast zahlt.' },
+    // Barzahlung mit Rueckgeld-Rechner: ohne „Gegeben" wird die Zahlung nicht
+    // hinzugefuegt – derselbe Grund wie beim Abschluss einer Barzahlung, auf
+    // DIESE Zahlung bezogen.
+    'getrennt.gegeben_fehlt': { text: 'Erst eintippen, was der Gast für diese Zahlung gibt – der Rückgeld-Rechner ist an.' },
     // --- Beleg weitergeben: Link, Teilen, E-Mail -----------------------------
     // Kopieren, Teilen und Senden fuehren zu demselben Ziel: der oeffentlichen
     // Belegseite (beleg.kasseneck.at/<fullReceiptId>). Kein Satz davon ist
@@ -108,29 +195,29 @@ const MELDUNGEN_ROH = {
     // Belege aus dem Altbestand tragen keine `fullReceiptId`; ohne sie gibt es
     // keine Belegseite. Der Satz nennt den Grund, sonst sucht der Kassier den
     // Fehler bei sich und versucht es ein zweites Mal.
-    'beleg.nicht_teilbar': { text: 'Für diesen Beleg gibt es keinen Link — er stammt aus einer älteren Kasse.' },
+    'beleg.nicht_teilbar': { text: 'Für diesen Beleg gibt es keinen Link – er stammt aus einer älteren Kasse.' },
     // Ein Testbeleg hat eine Belegseite, ist aber steuerlich nichts wert. Wer
     // den Link weitergibt, muss das vorher lesen, nicht hinterher.
-    'beleg.test_hinweis_teilen': { text: 'Test-Umgebung — der Beleg ist steuerlich nicht gültig.' },
+    'beleg.test_hinweis_teilen': { text: 'Test-Umgebung – der Beleg ist steuerlich nicht gültig.' },
     'beleg.mail_gesendet': { text: 'Der Beleg wurde an {an} gesendet.', platzhalter: ['an'] },
     'beleg.mail_adresse_ungueltig': { text: 'Diese E-Mail-Adresse ist nicht gültig.' },
-    'beleg.mail_zu_oft': { text: 'Dieser Beleg wurde schon oft gesendet — bitte später noch einmal.' },
+    'beleg.mail_zu_oft': { text: 'Dieser Beleg wurde schon oft gesendet – bitte später noch einmal.' },
     'beleg.mail_fehlgeschlagen': { text: 'Der Beleg konnte nicht gesendet werden. Bitte noch einmal versuchen.' },
     // Bewusst nicht derselbe Satz wie `beleg.nicht_gefunden`: dort scheitert das
     // Oeffnen, hier das Senden. Der Kassier steht vor einem Adressfeld und muss
     // lesen, dass nichts hinausgegangen ist.
-    'beleg.mail_nicht_gefunden': { text: 'Dieser Beleg wurde nicht gefunden — er konnte nicht gesendet werden.' },
+    'beleg.mail_nicht_gefunden': { text: 'Dieser Beleg wurde nicht gefunden – er konnte nicht gesendet werden.' },
     // --- Druck ---------------------------------------------------------------
     'druck.fehlgeschlagen': { text: 'Der Ausdruck ist fehlgeschlagen.' },
     'druck.nicht_moeglich': { text: 'Druck nicht möglich: {grund}', platzhalter: ['grund'] },
     'druck.testdruck_fehlgeschlagen': { text: 'Der Testdruck ist fehlgeschlagen.' },
     'druck.testdruck_nicht_moeglich': { text: 'Der Testdruck ist fehlgeschlagen: {grund}', platzhalter: ['grund'] },
-    'druck.kein_drucker': { text: 'Kein Bondrucker eingerichtet — in den Einstellungen unter Drucker & Lade.' },
+    'druck.kein_drucker': { text: 'Kein Bondrucker eingerichtet – in den Einstellungen unter Drucker & Lade.' },
     'druck.drucker_nicht_erreichbar': { text: 'Drucker nicht erreichbar.' },
     'druck.job_abgelaufen': { text: 'Drucker hat den Beleg nicht abgeholt (abgelaufen).', nur: ['web'] },
-    'druck.kein_drucker_gefunden': { text: 'Kein Drucker gefunden — ist er eingeschaltet und im selben Netz wie dieser Rechner?', nur: ['web'] },
-    'druck.nur_chrome': { text: '{weg}-Druck geht nur in Chrome oder Edge (Windows, Mac, Android) — nicht in Safari und nicht am iPad.', platzhalter: ['weg'], nur: ['web'] },
-    'druck.kein_weg_drucker': { text: 'Kein {weg}-Drucker verbunden — „{weg}-Drucker verbinden“ und den Drucker im Dialog wählen.', platzhalter: ['weg'], nur: ['web'] },
+    'druck.kein_drucker_gefunden': { text: 'Kein Drucker gefunden – ist er eingeschaltet und im selben Netz wie dieser Rechner?', nur: ['web'] },
+    'druck.nur_chrome': { text: '{weg}-Druck geht nur in Chrome oder Edge (Windows, Mac, Android) – nicht in Safari und nicht am iPad.', platzhalter: ['weg'], nur: ['web'] },
+    'druck.kein_weg_drucker': { text: 'Kein {weg}-Drucker verbunden – „{weg}-Drucker verbinden“ und den Drucker im Dialog wählen.', platzhalter: ['weg'], nur: ['web'] },
     // Der Drucker-Wizard: suchen, verbinden, Testdruck, QR-Probe, erst dann
     // speichern. Derselbe Ablauf in beiden Kassen — deshalb hat kein Satz ein
     // `nur`, obwohl der Weg zum Drucker verschieden ist (Bluetooth in der App,
@@ -141,7 +228,7 @@ const MELDUNGEN_ROH = {
     // Kein Modus druckt einen lesbaren QR-Code: gespeichert wird trotzdem (mit
     // Raster als Vorgabe), aber der Chef muss wissen, dass der QR-Code dann vom
     // Bildschirm gelesen werden muss — nach RKSV gehoert er an den Beleg.
-    'druck.wizard_qr_keiner_hinweis': { text: 'Kein QR-Code kam sauber — der Beleg zeigt den QR-Code dann am Bildschirm.' },
+    'druck.wizard_qr_keiner_hinweis': { text: 'Kein QR-Code kam sauber – der Beleg zeigt den QR-Code dann am Bildschirm.' },
     'druck.wizard_nichts_gekommen': { text: 'Nichts gekommen? Drucker an, Papier drin, richtiges Gerät gewählt?' },
     'druck.wizard_gespeichert': { text: '{name} ist eingerichtet.', platzhalter: ['name'] },
     // Abbrechen an jeder Stelle: nichts gespeichert. Der Satz sagt genau das,
@@ -151,24 +238,25 @@ const MELDUNGEN_ROH = {
     'bluetooth.freigabe_fehlt': { text: 'Bitte die Freigabe in den Geräte-Einstellungen erteilen.', nur: ['app'] },
     'bluetooth.suche_fehlgeschlagen': { text: 'Die Suche ist fehlgeschlagen: {grund}', platzhalter: ['grund'], nur: ['app'] },
     // --- Kasseneck Connect (nur Browser) -------------------------------------
-    'connect.antwortet_nicht': { text: 'Kasseneck Connect antwortet nicht — läuft das Programm auf diesem Rechner?', nur: ['web'] },
-    'connect.code_abgelaufen': { text: 'Der Kopplungs-Code ist abgelaufen — im Agent einen neuen erzeugen („kasseneck-connect pair“).', nur: ['web'] },
-    'connect.zu_viele_versuche': { text: 'Zu viele Fehlversuche — eine Minute warten und noch einmal versuchen.', nur: ['web'] },
-    'connect.drucker_antwortet_nicht': { text: 'Der Drucker antwortet nicht — Strom, Netzwerk und IP prüfen.', nur: ['web'] },
-    'connect.nicht_gekoppelt': { text: 'Diese Kasse ist mit Kasseneck Connect nicht gekoppelt — in den Einstellungen „Koppeln“ drücken.', nur: ['web'] },
-    'connect.drucker_unbekannt': { text: 'Diesen Drucker kennt Kasseneck Connect nicht (mehr) — bitte neu suchen.', nur: ['web'] },
+    'connect.antwortet_nicht': { text: 'Kasseneck Connect antwortet nicht – läuft das Programm auf diesem Rechner?', nur: ['web'] },
+    'connect.code_abgelaufen': { text: 'Der Kopplungs-Code ist abgelaufen – im Agent einen neuen erzeugen („kasseneck-connect pair“).', nur: ['web'] },
+    'connect.zu_viele_versuche': { text: 'Zu viele Fehlversuche – eine Minute warten und noch einmal versuchen.', nur: ['web'] },
+    'connect.drucker_antwortet_nicht': { text: 'Der Drucker antwortet nicht – Strom, Netzwerk und IP prüfen.', nur: ['web'] },
+    'connect.nicht_gekoppelt': { text: 'Diese Kasse ist mit Kasseneck Connect nicht gekoppelt – in den Einstellungen „Koppeln“ drücken.', nur: ['web'] },
+    'connect.drucker_unbekannt': { text: 'Diesen Drucker kennt Kasseneck Connect nicht (mehr) – bitte neu suchen.', nur: ['web'] },
     'connect.ursprung_nicht_freigegeben': { text: 'Kasseneck Connect nimmt von dieser Adresse nichts an (Ursprung nicht freigegeben).', nur: ['web'] },
-    'connect.nicht_installiert': { text: 'Kasseneck Connect nicht gefunden — bitte installieren.', nur: ['web'] },
+    'connect.nicht_installiert': { text: 'Kasseneck Connect nicht gefunden – bitte installieren.', nur: ['web'] },
+    'connect.entkoppeln_frage': { text: 'Diesen Browser wirklich von Connect trennen? Der Bondruck geht dann nicht mehr.', nur: ['web'] },
     // --- Einstellungen -------------------------------------------------------
     'einstellungen.laden_fehlgeschlagen': { text: 'Die Einstellungen konnten nicht geladen werden.' },
     'einstellungen.speichern_fehlgeschlagen': { text: 'Die Einstellung konnte nicht gespeichert werden.' },
-    'einstellungen.noch_nicht_geladen': { text: 'Noch nicht geladen — bitte kurz warten oder neu anmelden.' },
+    'einstellungen.noch_nicht_geladen': { text: 'Noch nicht geladen – bitte kurz warten oder neu anmelden.' },
     'einstellungen.ip_ungueltig': { text: 'Keine gültige IP-Adresse (z. B. 192.168.1.50).' },
     'entkopplung.fehlgeschlagen': { text: 'Entkoppeln fehlgeschlagen.' },
     'logo.hochladen_fehlgeschlagen': { text: 'Hochladen fehlgeschlagen.' },
     'logo.entfernen_fehlgeschlagen': { text: 'Entfernen fehlgeschlagen.' },
     // --- Nur App -------------------------------------------------------------
-    'app.nicht_im_browser': { text: 'Die Kassen-App läuft nicht im Browser — dafür gibt es kasse.kasseneck.at.', nur: ['app'] },
+    'app.nicht_im_browser': { text: 'Die Kassen-App läuft nicht im Browser – dafür gibt es kasse.kasseneck.at.', nur: ['app'] },
     'app.im_browser_oeffnen': { text: 'Bitte im Browser öffnen: {ziel}', platzhalter: ['ziel'], nur: ['app'] },
 };
 // Auf den gemeinsamen Typ gebracht: `Object.entries(MELDUNGEN)` liefert sonst
@@ -227,6 +315,148 @@ function belegMailFehler(code) {
     const fehler = exports.BELEG_MAIL_FEHLER;
     return (code !== undefined && code !== null && fehler[code]) || 'beleg.mail_fehlgeschlagen';
 }
+/**
+ * Storno eines Belegs mit mehreren Zahlungen, dazu der offene Ausgang
+ * (`STORNO_OUTCOME_UNKNOWN`, gilt fuer jedes Storno): welcher `code` des
+ * Backends welchen Satz bekommt. Dieselbe Idee wie BELEG_MAIL_FEHLER – beide Kassen
+ * entscheiden am Code, nie am Satz des Backends. Ein Code, der hier fehlt,
+ * geht den allgemeinen Weg der Storno-Fehler (`storno.fehlgeschlagen`).
+ */
+exports.STORNO_ZAHLUNG_FEHLER = {
+    STORNO_PAYMENTS_REQUIRED: 'storno.zahlungen_fehlen',
+    STORNO_REFUND_EXCEEDS_PAYMENT: 'storno.rueckgabe_zu_hoch',
+    STORNO_REFUND_REFERENCE_REQUIRED: 'storno.rueckgabe_ohne_bezug',
+    STORNO_REFUND_REFERENCE_UNKNOWN: 'storno.rueckgabe_bezug_unbekannt',
+    PAYMENTS_SUM_MISMATCH: 'storno.summe_passt_nicht',
+    STORNO_OUTCOME_UNKNOWN: 'storno.ergebnis_unklar',
+};
+/**
+ * Der Satz zu einem `code` des Backends beim Storno mit mehreren Zahlungen.
+ * Einen Code, den dieses Paket noch nicht kennt, faengt der allgemeine Satz
+ * `storno.fehlgeschlagen` auf – wie bei `belegMailFehler`.
+ */
+function stornoZahlungFehler(code) {
+    const fehler = exports.STORNO_ZAHLUNG_FEHLER;
+    return (code !== undefined && code !== null && fehler[code]) || 'storno.fehlgeschlagen';
+}
+/**
+ * Beschriftungen: Knoepfe, Ueberschriften, Zeilennamen – was kein Satz ist.
+ *
+ * Getrennt von MELDUNGEN, weil dort jeder Eintrag ein Satz ist (gross am
+ * Anfang, Satzzeichen am Schluss) und die Waechter beider Kassen daran
+ * Saetze erkennen. „Rest" oder „÷ {n}" sind keine Saetze, muessen aber in
+ * beiden Kassen gleich heissen. Dieselben Regeln sonst: Schluessel
+ * `bereich.name`, nie umgedeutet, Platzhalter exakt die im Text, `nur` nennt
+ * die Seite.
+ *
+ * Die Woerter der Zahlarten folgen dem Bon („Kartenzahlung", „Barzahlung",
+ * „Zahlung {n}", „davon Trinkgeld").
+ */
+const BESCHRIFTUNGEN_ROH = {
+    // --- Allgemein -------------------------------------------------------------
+    'allgemein.abbrechen': { text: 'Abbrechen' },
+    // Das X an einer Meldung nennt, WELCHE es ausblendet – bei mehreren
+    // Meldungen in der Ecke sonst fuer Vorlese-Programme lauter gleiche Knoepfe.
+    // `{meldung}` ist der Anfang des Satzes (gekuerzt), nicht der ganze.
+    'meldung.ausblenden': { text: 'Meldung ausblenden: {meldung}', platzhalter: ['meldung'] },
+    'meldung.warnung_ausblenden': { text: 'Verstanden – Warnung ausblenden: {meldung}', platzhalter: ['meldung'] },
+    // --- Kopplung und Abmelden -----------------------------------------------
+    'kopplung.neu_koppeln': { text: 'Neu koppeln' },
+    'abmelden.frage': { text: 'Wirklich abmelden?' },
+    'abmelden.weiter_arbeiten': { text: 'Weiter arbeiten' },
+    'geraet.entkoppeln': { text: 'Gerät entkoppeln' },
+    'connect.entkoppeln_bestaetigen': { text: 'Entkoppeln bestätigen', nur: ['web'] },
+    // --- Kassieren -------------------------------------------------------------
+    // Dieselben Woerter im gewohnten Kassieren und je Zahlung bei „Getrennt“.
+    'kassieren.trinkgeld': { text: 'Trinkgeld' },
+    'kassieren.kein': { text: 'kein' },
+    'kassieren.eigener_betrag': { text: 'Eigener Betrag' },
+    'kassieren.passend': { text: 'passend' },
+    'kassieren.gegeben_loeschen': { text: 'Gegeben löschen' },
+    'kassieren.es_fehlen_noch': { text: 'Es fehlen noch' },
+    'kassieren.rueckgeld': { text: 'Rückgeld' },
+    // Die Warte-Karte, solange der Betrag am Terminal steht; `{zeit}` ist der
+    // Rest des Kartenfensters als m:ss.
+    'kartenzahlung.betrag_am_terminal': { text: 'Betrag steht am Terminal' },
+    'kartenzahlung.karte_vorhalten': { text: 'Karte vorhalten oder stecken · noch {zeit}', platzhalter: ['zeit'] },
+    // --- Abschluss -------------------------------------------------------------
+    'abschluss.beleg_vorhanden': { text: 'Beleg ist vorhanden – erledigen' },
+    'abschluss.erledigen': { text: 'Erledigen' },
+    // --- Getrennt zahlen -----------------------------------------------------
+    'getrennt.knopf': { text: 'Getrennt' },
+    'getrennt.einstellung': { text: 'Getrennt zahlen' },
+    'getrennt.zu_zahlen': { text: 'Zu zahlen' },
+    'getrennt.offen': { text: 'Offen' },
+    'getrennt.zahlung': { text: 'Zahlung {n}', platzhalter: ['n'] },
+    'getrennt.betrag': { text: 'Betrag' },
+    'getrennt.rest': { text: 'Rest' },
+    'getrennt.teilen': { text: '÷ {n}', platzhalter: ['n'] },
+    'getrennt.trinkgeld_bezug': { text: '% von diesem Betrag' },
+    'getrennt.davon_trinkgeld': { text: 'davon Trinkgeld {betrag}', platzhalter: ['betrag'] },
+    'getrennt.entfernen': { text: 'Entfernen' },
+    'getrennt.alles_abbrechen': { text: 'Alles abbrechen' },
+    'getrennt.weiter_kassieren': { text: 'Weiter kassieren' },
+    'getrennt.alles_zurueckbuchen': { text: 'Alles zurückbuchen' },
+    'getrennt.am_terminal_zurueckgebucht': { text: 'Am Terminal zurückgebucht' },
+    'getrennt.karte_zurueckbuchen': { text: 'Karte zurückbuchen' },
+    'getrennt.trotzdem_neu_koppeln': { text: 'Trotzdem neu koppeln' },
+    'getrennt.zahlung_behalten': { text: 'Zahlung behalten' },
+    'getrennt.klaeren': { text: 'Klären' },
+    'getrennt.erneut_zurueckbuchen': { text: 'Erneut zurückbuchen' },
+    'getrennt.wurde_belastet': { text: 'Wurde belastet – übernehmen' },
+    'getrennt.nicht_belastet': { text: 'Nicht belastet – verwerfen' },
+    // Aufteilung: eigener Schritt nach „Weiter“, Tabs „Nach Positionen“ / „Betrag“.
+    'getrennt.weiter': { text: 'Weiter · {betrag} getrennt', platzhalter: ['betrag'] },
+    'getrennt.aufteilung': { text: 'Aufteilung' },
+    'getrennt.zurueck_zahlart': { text: 'Zurück zur Zahlart' },
+    'getrennt.tab_positionen': { text: 'Nach Positionen' },
+    'getrennt.tab_betrag': { text: 'Betrag' },
+    'getrennt.stueck_weniger': { text: '{name}: ein Stück weniger', platzhalter: ['name'] },
+    'getrennt.stueck_mehr': { text: '{name}: ein Stück mehr', platzhalter: ['name'] },
+    'getrennt.gegeben': { text: 'Gegeben (bar)' },
+    'getrennt.gegeben_rueckgeld': { text: 'Gegeben {gegeben} · Rückgeld {rueckgeld}', platzhalter: ['gegeben', 'rueckgeld'] },
+    // Je Zahlung oben die Zahlart (Umschalter, kein Ausloeser), unten EIN Knopf,
+    // der diese Zahlung mit der gewaehlten Zahlart kassiert.
+    'getrennt.zahlart': { text: 'Zahlart' },
+    'getrennt.art_bar': { text: 'Bar' },
+    'getrennt.art_karte': { text: 'Karte' },
+    'getrennt.zahlung_hinzufuegen': { text: 'Zahlung hinzufügen · {betrag}', platzhalter: ['betrag'] },
+    // Nach Positionen: die offenen Stueck als Kacheln in der grossen Flaeche;
+    // Antippen nimmt ein Stueck in diese Zahlung, „−“ an der Kachel eines heraus.
+    'getrennt.offene_positionen': { text: 'Offene Positionen' },
+    'getrennt.stueck_offen': { text: '{n} offen', platzhalter: ['n'] },
+    'getrennt.stueck_gewaehlt': { text: '{n} von {offen}', platzhalter: ['n', 'offen'] },
+    'getrennt.nichts_gewaehlt': { text: 'Noch nichts angetippt' },
+    'getrennt.alles_bezahlt': { text: 'Alles bezahlt' },
+    // --- Zahlarten in Listen (Kassieren, Storno, Belegliste) -----------------
+    'zahlart.kartenzahlung': { text: 'Kartenzahlung' },
+    'zahlart.barzahlung': { text: 'Barzahlung' },
+    // Beleg mit mehreren Zahlungen (`paymentMethod: 'mixed'` oder mehr als eine
+    // Zahlung): weder Bar noch Karte, auch nicht im Filter.
+    'zahlart.mehrere': { text: 'Mehrere' },
+    // --- Storno ----------------------------------------------------------------
+    'storno.titel': { text: 'Storno zu {beleg}', platzhalter: ['beleg'] },
+    // --- Storno eines Belegs mit mehreren Zahlungen --------------------------
+    'storno.wie_zurueckgeben': { text: 'Wie zurückgeben?' },
+    'storno.wie_bezahlt': { text: 'wie bezahlt' },
+    'storno.bar': { text: 'bar' },
+    'storno.alles_bar': { text: 'Alles bar' },
+    'storno.rest_der_zahlung': { text: 'Rest {betrag}', platzhalter: ['betrag'] },
+    'storno.differenz': { text: 'Differenz' },
+};
+exports.BESCHRIFTUNGEN = BESCHRIFTUNGEN_ROH;
+/** Die Beschriftung zum Schluessel, Platzhalter ersetzt; fehlt ein Wert, wirft es wie `meldung`. */
+function beschriftung(schluessel, werte = {}) {
+    return ersetze(`beschriftung(${schluessel})`, exports.BESCHRIFTUNGEN[schluessel].text, werte);
+}
+function ersetze(wo, text, werte) {
+    return text.replace(/\{([a-z]+)\}/g, (_, name) => {
+        const wert = werte[name];
+        if (wert === undefined)
+            throw new Error(`${wo}: Platzhalter {${name}} ohne Wert`);
+        return String(wert);
+    });
+}
 /** Der Satz zum Schluessel, Platzhalter ersetzt. Fehlt ein Wert, wirft es — ein `{status}` am Tresen waere schlimmer. */
 function meldung(schluessel, werte = {}) {
     const eintrag = exports.MELDUNGEN[schluessel];

package/dist/cjs/models/cancellation.d.ts

@@ -20,7 +20,7 @@ export type CancellationReason = keyof typeof CANCELLATION_REASONS;
 export declare function isCancellationReason(value: unknown): value is CancellationReason;
 /**
  * Stabile Fehlercodes von `cancelReceipt` — Zwilling von
- * `functions/storno-core.js` STORNO_FEHLERCODES. Das Backend legt sie bei
+ * `functions/gemeinsam/storno-core.js` STORNO_FEHLERCODES. Das Backend legt sie bei
  * jedem fachlichen Fehler als `code` neben die Meldung; das Paket reicht sie
  * als [KasseneckApiError.code] durch. **Entscheide am Code, nie am Text** —
  * die deutsche Meldung darf sich aendern, der Code nicht.
@@ -28,9 +28,12 @@ export declare function isCancellationReason(value: unknown): value is Cancellat
  * Nur Auth-/Parameterfehler (Sitzung abgelaufen, Pflichtfeld fehlt) kommen
  * ohne Code; dort bleibt `code` undefined.
  *
- * Die vier `STORNO_…`-Codes am Ende gehoeren zur Rueckzahlung je Zahlung
- * (mehrere Zahlungen je Beleg); Formfehler an `payments` selbst melden die
- * Codes aus [PAYMENT_ERROR_CODES].
+ * Die vier `STORNO_PAYMENTS_…`/`STORNO_REFUND_…`-Codes gehoeren zur
+ * Rueckzahlung je Zahlung (mehrere Zahlungen je Beleg); Formfehler an
+ * `payments` selbst melden die Codes aus [PAYMENT_ERROR_CODES].
+ * `STORNO_OUTCOME_UNKNOWN` heisst: der Storno-Beleg kann schon signiert sein,
+ * die Reservierung bleibt offen – nicht erneut stornieren, die Belegliste
+ * nach ein paar Minuten neu laden (unter `/v3`: `cancellation_outcome_unknown`).
  *
  * Die Werte hier sind die von `/v1` und intern. Unter `/v3` heissen die
  * Storno-Codes nach dem /v3-Vokabular anders (`already_cancelled`,
@@ -38,7 +41,7 @@ export declare function isCancellationReason(value: unknown): value is Cancellat
  * diese Namen kommen mit der Umstellung des Pakets auf `/v3`.
  * [isCancellationErrorCode] prueft darum exakt.
  */
-export declare const CANCELLATION_ERROR_CODES: readonly ["beleg_nicht_gefunden", "belegart_nicht_stornierbar", "trainingsbeleg", "bereits_storniert", "position_ungueltig", "menge_ueber_rest", "grund_unbekannt", "anmerkung_zu_lang", "items_ungueltig", "kasse_nicht_zugewiesen", "keine_berechtigung", "nur_eigene_belege", "kasse_unvollstaendig", "storno_fehlgeschlagen", "STORNO_PAYMENTS_REQUIRED", "STORNO_REFUND_EXCEEDS_PAYMENT", "STORNO_REFUND_REFERENCE_REQUIRED", "STORNO_REFUND_REFERENCE_UNKNOWN"];
+export declare const CANCELLATION_ERROR_CODES: readonly ["beleg_nicht_gefunden", "belegart_nicht_stornierbar", "trainingsbeleg", "bereits_storniert", "position_ungueltig", "menge_ueber_rest", "grund_unbekannt", "anmerkung_zu_lang", "items_ungueltig", "kasse_nicht_zugewiesen", "keine_berechtigung", "nur_eigene_belege", "kasse_unvollstaendig", "storno_fehlgeschlagen", "STORNO_PAYMENTS_REQUIRED", "STORNO_REFUND_EXCEEDS_PAYMENT", "STORNO_REFUND_REFERENCE_REQUIRED", "STORNO_REFUND_REFERENCE_UNKNOWN", "STORNO_OUTCOME_UNKNOWN"];
 export type CancellationErrorCode = (typeof CANCELLATION_ERROR_CODES)[number];
 export declare function isCancellationErrorCode(value: unknown): value is CancellationErrorCode;
 /** Bezug eines Storno-Belegs auf sein Original. */
@@ -78,6 +81,16 @@ export interface Cancellation {
      * nichts gewaehrt (Altbestand vor dieser Regel) — der naechste Storno holt nach.
      */
     promoAdjustmentCents?: Record<string, number>;
+    /**
+     * Rueckzahlung je Zahlung, die DIESER Storno-Eintrag auf eine Zahlung des
+     * Originals verbucht hat (`refundOf`) -- Zahlungs-ID auf positive Cent,
+     * Zwilling von `functions/gemeinsam/storno-core.js` `refundedByPayment`.
+     * Ueber alle Eintraege darf je Zahlung nie mehr zurueck, als bezahlt wurde
+     * (siehe dort `restJeZahlung`). Ein Eintrag ohne das Feld (vor dieser Regel
+     * oder ohne Zahlungsmodell gebucht) zaehlt dabei 0 je Zahlung. Auch am
+     * `pending`-Eintrag vorhanden, sobald reserviert wird.
+     */
+    refundedByPayment?: Record<string, number>;
 }
 /** Ab wann eine liegengebliebene Reservierung nicht mehr zaehlt (wie im Backend). */
 export declare const CANCELLATION_RESERVATION_MS = 120000;

package/dist/cjs/models/cancellation.js

@@ -26,7 +26,7 @@ function isCancellationReason(value) {
 }
 /**
  * Stabile Fehlercodes von `cancelReceipt` — Zwilling von
- * `functions/storno-core.js` STORNO_FEHLERCODES. Das Backend legt sie bei
+ * `functions/gemeinsam/storno-core.js` STORNO_FEHLERCODES. Das Backend legt sie bei
  * jedem fachlichen Fehler als `code` neben die Meldung; das Paket reicht sie
  * als [KasseneckApiError.code] durch. **Entscheide am Code, nie am Text** —
  * die deutsche Meldung darf sich aendern, der Code nicht.
@@ -34,9 +34,12 @@ function isCancellationReason(value) {
  * Nur Auth-/Parameterfehler (Sitzung abgelaufen, Pflichtfeld fehlt) kommen
  * ohne Code; dort bleibt `code` undefined.
  *
- * Die vier `STORNO_…`-Codes am Ende gehoeren zur Rueckzahlung je Zahlung
- * (mehrere Zahlungen je Beleg); Formfehler an `payments` selbst melden die
- * Codes aus [PAYMENT_ERROR_CODES].
+ * Die vier `STORNO_PAYMENTS_…`/`STORNO_REFUND_…`-Codes gehoeren zur
+ * Rueckzahlung je Zahlung (mehrere Zahlungen je Beleg); Formfehler an
+ * `payments` selbst melden die Codes aus [PAYMENT_ERROR_CODES].
+ * `STORNO_OUTCOME_UNKNOWN` heisst: der Storno-Beleg kann schon signiert sein,
+ * die Reservierung bleibt offen – nicht erneut stornieren, die Belegliste
+ * nach ein paar Minuten neu laden (unter `/v3`: `cancellation_outcome_unknown`).
  *
  * Die Werte hier sind die von `/v1` und intern. Unter `/v3` heissen die
  * Storno-Codes nach dem /v3-Vokabular anders (`already_cancelled`,
@@ -64,6 +67,7 @@ exports.CANCELLATION_ERROR_CODES = [
     'STORNO_REFUND_EXCEEDS_PAYMENT', // Rueckzahlungen auf eine Zahlung uebersteigen deren Rest
     'STORNO_REFUND_REFERENCE_REQUIRED', // Karten-Rueckzahlung ohne refundOf einer Kartenzahlung
     'STORNO_REFUND_REFERENCE_UNKNOWN', // refundOf nennt keine Zahlung des Originals
+    'STORNO_OUTCOME_UNKNOWN', // Ausgang offen: Storno-Beleg evtl. schon signiert, nicht wiederholen
 ];
 function isCancellationErrorCode(value) {
     return typeof value === 'string' && exports.CANCELLATION_ERROR_CODES.includes(value);

package/dist/cjs/models/payment-errors.js

@@ -24,7 +24,7 @@ exports.PAYMENT_ERROR_CODES = Object.freeze([
     'PAYMENTS_INVALID', // payments ist keine Liste oder hat mehr als 20 Eintraege
     'PAYMENT_METHOD_INVALID', // Zahlart unbekannt oder mixed
     'PAYMENT_AMOUNT_INVALID', // amountCents keine Ganzzahl, 0 oder falsches Vorzeichen
-    'PAYMENT_TENDERED_INVALID', // tenderedCents an Nicht-Bar-Zahlung, zu klein oder doppelt
+    'PAYMENT_TENDERED_INVALID', // tenderedCents an Nicht-Bar-Zahlung, zu klein oder am Storno
     'PAYMENT_PROVIDER_INVALID', // Karte ohne/mit unbekanntem provider, providerPaymentId fehlt
     'PAYMENT_PROVIDER_NOT_ALLOWED', // Anbieterfelder an einer Zahlung, die weder Karte noch online ist
     'PAYMENTS_SUM_MISMATCH', // Summe != Zahlbetrag (Antwort nennt data.expectedCents)

package/dist/cjs/models/receipt-payment.d.ts

@@ -57,7 +57,8 @@ export interface ReceiptPaymentPayload {
  *
  * - `method`: jede Zahlungsart ausser `mixed`.
  * - `amountCents`: ganze Cent, am Verkauf > 0, am Storno < 0.
- * - `tenderedCents`: nur bei Barzahlung am Verkauf, hoechstens an einer Zahlung.
+ * - `tenderedCents`: nur bei Barzahlung am Verkauf; jede Barzahlung darf ihren
+ *   eigenen gegebenen Betrag tragen (getrennt zahlen: Rueckgeld je Gast).
  * - `provider`/`providerPaymentId`/`providerData`: bei Karten Pflicht
  *   (`providerPaymentId` ausser bei `custom`), bei `online` optional, sonst
  *   nicht erlaubt; am Storno beschreiben sie die Erstattung und sind optional.

package/dist/cjs/models/receipt.js

@@ -100,8 +100,24 @@ function leseStorno(eintrag) {
         ...(eintrag.promoAdjustmentCents && typeof eintrag.promoAdjustmentCents === 'object'
             ? { promoAdjustmentCents: Object.fromEntries(Object.entries(eintrag.promoAdjustmentCents).map(([k, v]) => [k, Number(v)])) }
             : {}),
+        ...(eintrag.refundedByPayment && typeof eintrag.refundedByPayment === 'object' && !Array.isArray(eintrag.refundedByPayment)
+            ? { refundedByPayment: gueltigeRueckzahlungen(eintrag.refundedByPayment) }
+            : {}),
     };
 }
+// Nur ganzzahlige, nicht-negative Cent-Betraege je Zahlungs-ID; ein Eintrag,
+// der das nicht erfuellt (negativ, Kommazahl, kein Zahlenwert), faellt weg --
+// die uebrigen bleiben. Zwilling der Backend-Erzeugung (storno-core.js
+// pruefeRueckzahlungen), die selbst nur so etwas ablegt.
+function gueltigeRueckzahlungen(rueckzahlungen) {
+    const raus = {};
+    for (const [id, wert] of Object.entries(rueckzahlungen)) {
+        const cents = Number(wert);
+        if (Number.isInteger(cents) && cents >= 0)
+            raus[id] = cents;
+    }
+    return raus;
+}
 /**
  * Zwischensumme in **Cent** — Positionen plus verkaufte Wertgutscheine minus
  * eingeloeste Promotionsgutscheine. Wertgutschein-Einloesungen wirken erst auf