@kreiseck/kasseneck-api 0.30.0 → 1.0.0-rc.1

package/dist/esm/models/receipt-email.js

@@ -1,28 +1,70 @@
+import { bekannterCode, feldfehlerVon } from '../client/fehlercodes.js';
+/** Die Codes des Versands selbst (`errorCodes.receiptEmail`); jeder hat einen Satz im Textkatalog. */
+export const RECEIPT_EMAIL_SEND_ERROR_CODES = Object.freeze([
+    'invalid_address', // Empfaengeradresse unbrauchbar (Pruefung im Backend)
+    'receipt_not_found', // Beleg gibt es nicht ODER er gehoert einer anderen Kasse
+    'too_many_requests', // Schleuse: 5 Mails je Beleg (24 h), 30 je Kasse und Stunde
+    'send_failed', // die Mail selbst ging nicht hinaus
+]);
 /**
- * Beleg per E-Mail — Zwilling von `functions/beleg-mail-core.js`.
- *
- * Hier steht nur der Fehlercode-Katalog: der Aufruf selbst ist
- * [sendReceiptEmail] (client/receipts.ts), und was verschickt wird, ist ein
- * **Link auf die oeffentliche Belegseite** — der Beleg selbst bleibt
- * unberuehrt (BAO §131/RKSV), das Versandprotokoll fuehrt das Backend in einer
- * Unter-Sammlung neben ihm.
+ * Fehlercodes von `sendReceiptEmail` unter `/v3`: die Versandcodes
+ * ([RECEIPT_EMAIL_SEND_ERROR_CODES]) und dahinter (ab 1.0) die Codes, die
+ * Anmeldung und Rand auf diesem Endpunkt erzeugen koennen: `errorCodes.auth`
+ * ohne die sieben des Partner-Zugangs und `errorCodes.edge` (`not_found`,
+ * `dialect_mismatch`, `response_translation_failed` ...). Das Paket reicht sie
+ * als [KasseneckApiError.code] durch; ein Code ausserhalb bleibt dort lesbar.
+ * Zuletzt `route_missing` (Code des Pakets).
  */
-/**
- * Stabile Fehlercodes von `sendReceiptEmail` — Zwilling von
- * `beleg-mail-core.js` 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.
- *
- * Nur Auth-/Parameterfehler (Sitzung abgelaufen, Pflichtfeld fehlt) kommen
- * ohne Code; dort bleibt `code` undefined.
- */
-export const RECEIPT_EMAIL_ERROR_CODES = [
-    'adresse_ungueltig', // Empfaengeradresse unbrauchbar (Pruefung im Backend)
-    'beleg_nicht_gefunden', // Beleg gibt es nicht ODER er gehoert einer anderen Kasse
-    'zu_oft', // Schleuse: 5 Mails je Beleg (24 h), 30 je Kasse und Stunde
-    'versand_fehlgeschlagen', // die Mail selbst ging nicht hinaus
-];
+export const RECEIPT_EMAIL_ERROR_CODES = Object.freeze([
+    ...RECEIPT_EMAIL_SEND_ERROR_CODES,
+    // Anmeldung und Rand (errorCodes.auth ohne Partner-Zugang, errorCodes.edge)
+    'account_not_found',
+    'admin_required',
+    'cashregister_not_assigned',
+    'cashregister_not_found',
+    'cashregister_token_invalid',
+    'cashregister_token_missing',
+    'dialect_mismatch',
+    'internal_translation_error',
+    'live_not_enabled',
+    'method_not_allowed',
+    'mfa_required',
+    'not_found',
+    'register_user_no_business',
+    'register_user_not_allowed',
+    'register_user_not_found',
+    'response_translation_failed',
+    'session_expired',
+    'session_other_cashregister',
+    'unauthorized',
+    'user_disabled',
+    'user_verification_failed',
+    'validation',
+    // Code des Pakets (CLIENT_ERROR_CODES; response_unreadable nur an signierenden Aufrufen)
+    'route_missing',
+]);
 export function isReceiptEmailErrorCode(value) {
     return typeof value === 'string' && RECEIPT_EMAIL_ERROR_CODES.includes(value);
 }
+const RECEIPTEMAIL_BEKANNT = new Set(RECEIPT_EMAIL_ERROR_CODES);
+/** Der Code eines geworfenen Fehlers, wenn er in [RECEIPT_EMAIL_ERROR_CODES] steht; sonst `undefined`. */
+export function receiptEmailErrorCode(error) {
+    return bekannterCode(error, RECEIPTEMAIL_BEKANNT);
+}
+/**
+ * Kurzform fuer `catch (e) { if (isReceiptEmailError(e, 'too_many_requests')) … }`.
+ * Ohne `code`: traegt der Fehler ueberhaupt einen Code aus [RECEIPT_EMAIL_ERROR_CODES]?
+ */
+export function isReceiptEmailError(error, code) {
+    const gefunden = receiptEmailErrorCode(error);
+    return gefunden !== undefined && (code === undefined || gefunden === code);
+}
+/**
+ * Versandweg der Belegmail (Katalog `MAILWEG`): Postfach des Betriebs,
+ * Plattform, oder Plattform als Rueckfall, weil das eigene Postfach scheiterte.
+ */
+export const RECEIPT_EMAIL_VIAS = Object.freeze(['own', 'platform', 'platform_fallback']);
+/** Die Feldfehler einer `validation`-Antwort; leer, wenn es keine sind. */
+export function receiptEmailFieldErrors(error) {
+    return feldfehlerVon(error);
+}

package/dist/esm/models/receipt-errors.d.ts

@@ -0,0 +1,39 @@
+import { KasseneckApiError } from '../client/errors.js';
+/**
+ * Fehlercodes von `createReceipt` und `getReceipt` unter `/v3` (Vokabular
+ * `errorCodes.receiptMessagesByEndpoint`); dazu kommen die Zahlungscodes aus
+ * [PAYMENT_ERROR_CODES] und die des Rands (`validation`, `dialect_mismatch`, …).
+ *
+ * `receipt_outcome_unknown` heisst: der Beleg ist moeglicherweise signiert
+ * (`outcome: 'unknown'`). Nie wiederholen, sondern die Belegliste nachlesen.
+ *
+ * Dahinter (ab 1.0) die Codes, die Anmeldung und Rand auf diesem Endpunkt
+ * erzeugen koennen: `errorCodes.auth` ohne die sieben des Partner-Zugangs und
+ * `errorCodes.edge` (`not_found`, `dialect_mismatch`, `response_translation_failed`
+ * ...). Zuletzt die Codes des Pakets selbst: `route_missing` und
+ * `response_unreadable` (Erfolg gemeldet, Antwort unlesbar, Ausgang unklar).
+ * Die Zahlungscodes (`payments_sum_mismatch`, `payment_method_not_supported`
+ * ...) stehen in [PAYMENT_ERROR_CODES]. Ein Code ausserhalb bleibt ueber
+ * `KasseneckApiError.code` lesbar.
+ */
+export declare const RECEIPT_ERROR_CODES: readonly ["cancellation_reference_unavailable", "cashregister_closed", "cashregister_decommissioned", "final_receipt_expired", "final_receipt_not_allowed", "module_inactive", "not_permitted", "receipt_limit_exceeded", "receipt_not_found", "receipt_outcome_unknown", "receipt_type_invalid", "signature_incomplete", "signature_missing", "signing_failed", "small_business_vat_not_allowed", "tip_invalid", "tip_not_allowed", "tip_recipient_unknown", "validation", "account_not_found", "admin_required", "cashregister_not_assigned", "cashregister_not_found", "cashregister_token_invalid", "cashregister_token_missing", "dialect_mismatch", "internal_translation_error", "live_not_enabled", "method_not_allowed", "mfa_required", "not_found", "register_user_no_business", "register_user_not_allowed", "register_user_not_found", "response_translation_failed", "session_expired", "session_other_cashregister", "unauthorized", "user_disabled", "user_verification_failed", "route_missing", "response_unreadable"];
+export type ReceiptErrorCode = (typeof RECEIPT_ERROR_CODES)[number];
+export declare function isReceiptErrorCode(value: unknown): value is ReceiptErrorCode;
+/** Der Code eines geworfenen Fehlers, wenn er in [RECEIPT_ERROR_CODES] steht; sonst `undefined`. */
+export declare function receiptErrorCode(error: unknown): ReceiptErrorCode | undefined;
+/**
+ * Kurzform fuer `catch (e) { if (isReceiptError(e, 'signing_failed')) … }`.
+ * Ohne `code`: traegt der Fehler ueberhaupt einen Code aus [RECEIPT_ERROR_CODES]?
+ */
+export declare function isReceiptError(error: unknown, code?: ReceiptErrorCode): error is KasseneckApiError;
+/** Ein Feldfehler aus `data.errors[]` einer `validation`-Antwort der Belegwelt. */
+export interface ReceiptFieldError {
+    /** Feldpfad in der gesendeten Anfrage, z. B. `items.0.vatRate` oder `payments.1.amountCents`. */
+    field: string;
+    message: string;
+}
+/**
+ * Die Feldfehler einer `validation`-Antwort von `createReceipt`,
+ * `cancelReceipt` oder `sendReceiptEmail`; leer, wenn es keine sind.
+ */
+export declare function receiptFieldErrors(error: unknown): ReceiptFieldError[];

package/dist/esm/models/receipt-errors.js

@@ -0,0 +1,87 @@
+import { bekannterCode, feldfehlerVon } from '../client/fehlercodes.js';
+/**
+ * Fehlercodes von `createReceipt` und `getReceipt` unter `/v3` (Vokabular
+ * `errorCodes.receiptMessagesByEndpoint`); dazu kommen die Zahlungscodes aus
+ * [PAYMENT_ERROR_CODES] und die des Rands (`validation`, `dialect_mismatch`, …).
+ *
+ * `receipt_outcome_unknown` heisst: der Beleg ist moeglicherweise signiert
+ * (`outcome: 'unknown'`). Nie wiederholen, sondern die Belegliste nachlesen.
+ *
+ * Dahinter (ab 1.0) die Codes, die Anmeldung und Rand auf diesem Endpunkt
+ * erzeugen koennen: `errorCodes.auth` ohne die sieben des Partner-Zugangs und
+ * `errorCodes.edge` (`not_found`, `dialect_mismatch`, `response_translation_failed`
+ * ...). Zuletzt die Codes des Pakets selbst: `route_missing` und
+ * `response_unreadable` (Erfolg gemeldet, Antwort unlesbar, Ausgang unklar).
+ * Die Zahlungscodes (`payments_sum_mismatch`, `payment_method_not_supported`
+ * ...) stehen in [PAYMENT_ERROR_CODES]. Ein Code ausserhalb bleibt ueber
+ * `KasseneckApiError.code` lesbar.
+ */
+export const RECEIPT_ERROR_CODES = Object.freeze([
+    'cancellation_reference_unavailable',
+    'cashregister_closed',
+    'cashregister_decommissioned',
+    'final_receipt_expired',
+    'final_receipt_not_allowed',
+    'module_inactive',
+    'not_permitted',
+    'receipt_limit_exceeded',
+    'receipt_not_found',
+    'receipt_outcome_unknown',
+    'receipt_type_invalid',
+    'signature_incomplete',
+    'signature_missing',
+    'signing_failed',
+    'small_business_vat_not_allowed',
+    'tip_invalid',
+    'tip_not_allowed',
+    'tip_recipient_unknown',
+    'validation',
+    // Anmeldung und Rand (errorCodes.auth ohne Partner-Zugang, errorCodes.edge)
+    'account_not_found',
+    'admin_required',
+    'cashregister_not_assigned',
+    'cashregister_not_found',
+    'cashregister_token_invalid',
+    'cashregister_token_missing',
+    'dialect_mismatch',
+    'internal_translation_error',
+    'live_not_enabled',
+    'method_not_allowed',
+    'mfa_required',
+    'not_found',
+    'register_user_no_business',
+    'register_user_not_allowed',
+    'register_user_not_found',
+    'response_translation_failed',
+    'session_expired',
+    'session_other_cashregister',
+    'unauthorized',
+    'user_disabled',
+    'user_verification_failed',
+    // Codes des Pakets (CLIENT_ERROR_CODES)
+    'route_missing',
+    'response_unreadable',
+]);
+export function isReceiptErrorCode(value) {
+    return typeof value === 'string' && RECEIPT_ERROR_CODES.includes(value);
+}
+const RECEIPT_BEKANNT = new Set(RECEIPT_ERROR_CODES);
+/** Der Code eines geworfenen Fehlers, wenn er in [RECEIPT_ERROR_CODES] steht; sonst `undefined`. */
+export function receiptErrorCode(error) {
+    return bekannterCode(error, RECEIPT_BEKANNT);
+}
+/**
+ * Kurzform fuer `catch (e) { if (isReceiptError(e, 'signing_failed')) … }`.
+ * Ohne `code`: traegt der Fehler ueberhaupt einen Code aus [RECEIPT_ERROR_CODES]?
+ */
+export function isReceiptError(error, code) {
+    const gefunden = receiptErrorCode(error);
+    return gefunden !== undefined && (code === undefined || gefunden === code);
+}
+/**
+ * Die Feldfehler einer `validation`-Antwort von `createReceipt`,
+ * `cancelReceipt` oder `sendReceiptEmail`; leer, wenn es keine sind.
+ */
+export function receiptFieldErrors(error) {
+    return feldfehlerVon(error);
+}

package/dist/esm/models/receipt-item.d.ts

@@ -29,7 +29,7 @@ export interface ReceiptItem {
     priceCents: number;
     /**
      * Trinkgeld-Position (vom Backend aus dem Parameter `tip` erzeugt, siehe
-     * [ReceiptCommonOptions.tip]) oder Rabatt-Position (`verteileRabatt`).
+     * [ReceiptCommonOptions.tip]) oder Rabatt-Position (`distributeDiscount`).
      * Mitarbeiter-Trinkgeld ist Durchlaeufer (0 %, kein Umsatz),
      * Inhaber-Trinkgeld (`recipient.owner`) Umsatz. Rabatt-Positionen sind
      * negative Entgeltminderungen je Steuersatz; die Kennzeichnung steuert nur
@@ -40,6 +40,11 @@ export interface ReceiptItem {
     recipient?: TipRecipient | null;
     /** Zahlart der Trinkgeld-Position (kann von der des Belegs abweichen). */
     paymentMethod?: string;
+    /**
+     * Nur Personal-Trinkgeld: hat der Empfaenger das Geld schon (`true`) oder
+     * behaelt der Betrieb es und schuldet es (`false`)? Fehlt bei Altbelegen.
+     */
+    receivedImmediately?: boolean;
     /**
      * Artikel-Verweis (Artikelstamm) — Grundlage der Erloesgruppen-Zuordnung
      * im Bericht. Optional; Handeingaben haben keinen.
@@ -70,6 +75,7 @@ export interface ReceiptItemPayload {
     kind?: 'tip' | 'discount';
     recipient?: TipRecipient | null;
     paymentMethod?: string;
+    receivedImmediately?: boolean;
     /** Artikel-Verweis, siehe [ReceiptItem.articleId]. */
     articleId?: string;
 }
@@ -93,6 +99,8 @@ export interface ReceiptItemPayloadRead {
     kind?: string | null;
     recipient?: TipRecipient | null;
     paymentMethod?: string | null;
+    /** Trinkgeld-Position, siehe [ReceiptItem.receivedImmediately]. */
+    receivedImmediately?: boolean | null;
     /** v2: Menge */
     quantity?: number | null;
     /** v2: Einzelpreis in Cent */

package/dist/esm/models/receipt-item.js

@@ -27,6 +27,8 @@ export function toReceiptItemPayload(item) {
         nutzlast.recipient = item.recipient ?? null;
         if (item.paymentMethod != null)
             nutzlast.paymentMethod = item.paymentMethod;
+        if (typeof item.receivedImmediately === 'boolean')
+            nutzlast.receivedImmediately = item.receivedImmediately;
     }
     // Rabatt-Kennzeichnung reist mit — sonst kaeme ein Storno dieser Position
     // am Bon wieder als gewoehnliche Warenzeile mit "1 x" an.
@@ -71,6 +73,7 @@ export function fromReceiptItemPayload(payload) {
                 kind: 'tip',
                 recipient: payload.recipient ?? null,
                 ...(payload.paymentMethod != null ? { paymentMethod: payload.paymentMethod } : {}),
+                ...(typeof payload.receivedImmediately === 'boolean' ? { receivedImmediately: payload.receivedImmediately } : {}),
             }
             : payload.kind === 'discount'
                 ? { kind: 'discount' }

package/dist/esm/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/esm/models/receipt-summary.d.ts

@@ -1,4 +1,5 @@
 import { KeckPaymentMethod, ReceiptType } from '../enums/index.js';
+import { type CancellationStatus } from './cancellation.js';
 import { type ReceiptPayment, type ReceiptPaymentPayload } from './receipt-payment.js';
 /**
  * Belegzeile einer Liste — die Form, die `listMyReceipts` liefert
@@ -23,7 +24,7 @@ import { type ReceiptPayment, type ReceiptPaymentPayload } from './receipt-payme
 /** Anlass eines Nullbelegs (Backend: cashregister-lifecycle ZERO_KINDS). */
 export declare const ZERO_KINDS: readonly ["monthly", "annual", "annual_replacement", "outage_end", "final", "manual"];
 export type ZeroKind = (typeof ZERO_KINDS)[number];
-export declare function istZeroKind(w: unknown): w is ZeroKind;
+export declare function isZeroKind(w: unknown): w is ZeroKind;
 export interface ReceiptSummary {
     receiptId: string;
     /** Fortlaufender Belegzaehler der Kasse; fehlt bei Alt-Belegen. */
@@ -60,8 +61,13 @@ export interface ReceiptSummary {
         timeStamp?: string;
     };
     cancellationReason?: string;
-    /** offen | teil | voll -- Storno-Stand des Originals. */
-    stornoStand: 'offen' | 'teil' | 'voll';
+    /**
+     * Storno-Stand des Originals: `none`, `partial` oder `full`. Ein Wert, den
+     * dieses Paket nicht kennt, kommt sichtbar als `'unknown'` an, nie still als
+     * `none`: die Kasse bietet dann keinen Storno an, bis sie den Beleg einzeln
+     * liest. Fehlt das Feld in der Antwort, fehlt es auch hier.
+     */
+    cancellationStatus?: CancellationStatus | 'unknown';
     /** Nur am Nullbeleg, nur fuer Kassen-Benutzer: Anlass (monthly, annual, annual_replacement, outage_end, final, manual). */
     zeroKind?: ZeroKind;
     /**
@@ -96,7 +102,7 @@ export interface ReceiptSummaryPayload {
         timeStamp?: string | null;
     } | null;
     cancellationReason?: string | null;
-    stornoStand?: string | null;
+    cancellationStatus?: string | null;
     zeroKind?: string | null;
     payments?: ReceiptPaymentPayload[] | null;
 }

package/dist/esm/models/receipt-summary.js

@@ -1,6 +1,7 @@
 import { KeckPaymentMethod, ReceiptType } from '../enums/index.js';
 import { euroToCents } from '../money.js';
 import { readEnumKey } from './enum-payload.js';
+import { CANCELLATION_STATUSES } from './cancellation.js';
 import { fromReceiptPaymentPayload } from './receipt-payment.js';
 /**
  * Belegzeile einer Liste — die Form, die `listMyReceipts` liefert
@@ -24,7 +25,7 @@ import { fromReceiptPaymentPayload } from './receipt-payment.js';
  */
 /** Anlass eines Nullbelegs (Backend: cashregister-lifecycle ZERO_KINDS). */
 export const ZERO_KINDS = ['monthly', 'annual', 'annual_replacement', 'outage_end', 'final', 'manual'];
-export function istZeroKind(w) {
+export function isZeroKind(w) {
     return typeof w === 'string' && ZERO_KINDS.includes(w);
 }
 export function fromReceiptSummaryPayload(payload) {
@@ -47,8 +48,13 @@ export function fromReceiptSummaryPayload(payload) {
                 ...(typeof payload.cancellationOf.timeStamp === 'string' && payload.cancellationOf.timeStamp ? { timeStamp: payload.cancellationOf.timeStamp } : {}),
             } } : {}),
         ...(payload.cancellationReason ? { cancellationReason: payload.cancellationReason } : {}),
-        stornoStand: payload.stornoStand === 'teil' || payload.stornoStand === 'voll' ? payload.stornoStand : 'offen',
-        ...(istZeroKind(payload.zeroKind) ? { zeroKind: payload.zeroKind } : {}),
+        ...(payload.cancellationStatus == null
+            ? {}
+            : { cancellationStatus: isCancellationStatus(payload.cancellationStatus) ? payload.cancellationStatus : 'unknown' }),
+        ...(isZeroKind(payload.zeroKind) ? { zeroKind: payload.zeroKind } : {}),
         ...(Array.isArray(payload.payments) ? { payments: payload.payments.map(fromReceiptPaymentPayload) } : {}),
     };
 }
+function isCancellationStatus(wert) {
+    return typeof wert === 'string' && CANCELLATION_STATUSES.includes(wert);
+}

package/dist/esm/models/receipt.d.ts

@@ -18,8 +18,15 @@ import { type ReceiptPayment, type ReceiptPaymentPayload } from './receipt-payme
  * echten Zeitpunkt um (uneinheitliches Server-Format, siehe dort).
  *
  * `paymentMethod`/`receiptType`/`creditCardProvider` sind beim Lesen entweder
- * der bekannte Enum-Eintrag oder — bei einem der Nutzlast unbekannten
- * Schluessel — der rohe String (siehe `enum-payload.ts`, `readEnumKey`).
+ * der bekannte Enum-Eintrag oder, bei einem der Nutzlast unbekannten
+ * Schluessel, der rohe String (siehe `enum-payload.ts`, `readEnumKey`).
+ *
+ * **Zahlungen stehen in `payments`.** `paymentMethod` vergibt der Server
+ * (`mixed` bei mehreren Zahlarten); gesendet wird es unter `/v3` nie. Die
+ * Anbieterdaten (`payments[].providerPaymentId`/`providerData`, bei
+ * Altbelegen `cardPaymentId`/`cardPaymentData`) liefert nur der Kassenweg
+ * (Kanal `app`, `kasse.kasseneck.at/api/v3`); am oeffentlichen Weg fehlen
+ * sie. Darum sind sie hier optional.
  */
 export interface Receipt {
     receiptId: string;
@@ -61,6 +68,17 @@ export interface Receipt {
      * Kartenfelder. Siehe [ReceiptPayment].
      */
     payments?: ReceiptPayment[];
+    /** Kennung der Kopf-Version (Firmenkopf, wie er fuer diesen Beleg galt). */
+    headerVersionId?: string;
+    /** Layout-Regelwerk, in dem der Beleg ausgestellt wurde. */
+    layoutRuleset?: number;
+    /** Nur an Nullbelegen: Registrierdaten fuer den Block „Prüfangaben“. */
+    registrationInfo?: RegistrationInfo;
+}
+/** Registrierdaten von Signaturkarte und Kasse (Zeitstempel oder `null`, wenn unbekannt). */
+export interface RegistrationInfo {
+    cardRegisteredAt: string | null;
+    cashregisterRegisteredAt: string | null;
 }
 export interface ReceiptPayload {
     qr: string;
@@ -101,6 +119,12 @@ export interface ReceiptPayloadRead extends Omit<ReceiptPayload, 'items' | 'vouc
     cancellationReason?: string | null;
     zeroKind?: string | null;
     cancellations?: Cancellation[] | null;
+    headerVersionId?: string | null;
+    layoutRuleset?: number | null;
+    registrationInfo?: {
+        cardRegisteredAt?: string | null;
+        cashregisterRegisteredAt?: string | null;
+    } | null;
 }
 /**
  * Schreibt die Nutzlast in der **neuen** Form — sie **normalisiert, statt zu
@@ -114,6 +138,11 @@ export interface ReceiptPayloadRead extends Omit<ReceiptPayload, 'items' | 'vouc
  */
 export declare function toReceiptPayload(receipt: Receipt): ReceiptPayload;
 export declare function fromReceiptPayload(payload: ReceiptPayloadRead): Receipt;
+/** Registrierdaten lesen; ein fehlender oder leerer Zeitstempel wird `null`. */
+export declare function readRegistrationInfo(roh: {
+    cardRegisteredAt?: unknown;
+    cashregisterRegisteredAt?: unknown;
+}): RegistrationInfo;
 /**
  * Zwischensumme in **Cent** — Positionen plus verkaufte Wertgutscheine minus
  * eingeloeste Promotionsgutscheine. Wertgutschein-Einloesungen wirken erst auf

package/dist/esm/models/receipt.js

@@ -2,7 +2,7 @@ import { ReceiptType, KeckPaymentMethod, CreditCardProvider, VoucherAction, Vouc
 import { readEnumKey, requireEnumKey } from './enum-payload.js';
 import { toReceiptItemPayload, fromReceiptItemPayload, receiptItemTotalCents, } from './receipt-item.js';
 import { toVoucherPayload, fromVoucherPayload } from './voucher.js';
-import { istZeroKind } from './receipt-summary.js';
+import { isZeroKind } from './receipt-summary.js';
 import { fromReceiptPaymentPayload, toReceiptPaymentPayload } from './receipt-payment.js';
 /**
  * Schreibt die Nutzlast in der **neuen** Form — sie **normalisiert, statt zu
@@ -78,11 +78,21 @@ export function fromReceiptPayload(payload) {
                 ...(typeof payload.cancellationOf.timeStamp === 'string' && payload.cancellationOf.timeStamp ? { timeStamp: payload.cancellationOf.timeStamp } : {}),
             } } : {}),
         ...(payload.cancellationReason ? { cancellationReason: payload.cancellationReason } : {}),
-        ...(istZeroKind(payload.zeroKind) ? { zeroKind: payload.zeroKind } : {}),
+        ...(isZeroKind(payload.zeroKind) ? { zeroKind: payload.zeroKind } : {}),
         ...(payload.cancellations ? { cancellations: payload.cancellations.map(leseStorno) } : {}),
         ...(Array.isArray(payload.payments) ? { payments: payload.payments.map(fromReceiptPaymentPayload) } : {}),
+        ...(typeof payload.headerVersionId === 'string' && payload.headerVersionId !== '' ? { headerVersionId: payload.headerVersionId } : {}),
+        ...(typeof payload.layoutRuleset === 'number' ? { layoutRuleset: payload.layoutRuleset } : {}),
+        ...(payload.registrationInfo != null && typeof payload.registrationInfo === 'object'
+            ? { registrationInfo: readRegistrationInfo(payload.registrationInfo) }
+            : {}),
     };
 }
+/** Registrierdaten lesen; ein fehlender oder leerer Zeitstempel wird `null`. */
+export function readRegistrationInfo(roh) {
+    const zeit = (v) => (typeof v === 'string' && v !== '' ? v : null);
+    return { cardRegisteredAt: zeit(roh.cardRegisteredAt), cashregisterRegisteredAt: zeit(roh.cashregisterRegisteredAt) };
+}
 function leseStorno(eintrag) {
     return {
         ...(eintrag.receiptId !== undefined ? { receiptId: eintrag.receiptId } : {}),
@@ -94,8 +104,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

package/dist/esm/models/voucher.d.ts

@@ -18,16 +18,17 @@ export interface Voucher {
     valueCents?: number;
 }
 /**
- * Nutzlast: traegt **beide** Felder, `value` (Euro) und `valueCents` (Cent).
- * Das Backend erwartet das Euro-Feld weiterhin (Altkompatibilitaet) — die
- * Umwandlung passiert nur hier, an dieser einen Stelle.
+ * Nutzlast eines Gutscheins. Geschrieben wird nur `valueCents` (ganze Cent);
+ * `value` (Euro) kommt nur beim Lesen vor: der Server legt es in seinen
+ * Antworten daneben, gelesen wird es nur, wenn `valueCents` fehlt.
+ * `name` und `code` gehen nur hinaus, wenn sie gesetzt sind.
  */
 export interface VoucherPayload {
-    name: string | null;
-    code: string | null;
+    name?: string | null;
+    code?: string | null;
     action: string;
     type: string;
-    value: number | null;
+    value?: number | null;
     valueCents: number | null;
 }
 export declare function toVoucherPayload(voucher: Voucher): VoucherPayload;

package/dist/esm/models/voucher.js

@@ -3,16 +3,11 @@ import { euroToCents } from '../money.js';
 import { readEnumKey, requireEnumKey } from './enum-payload.js';
 export function toVoucherPayload(voucher) {
     return {
-        name: voucher.name ?? null,
-        code: voucher.code ?? null,
-        // Schreibpfad bleibt streng: action/type sehen fuer bekannte und
-        // unbekannte Werte gleich aus (reine Strings) — erst der Lookup hier
-        // entscheidet, ob geschrieben werden darf.
         action: requireEnumKey(VoucherAction, voucher.action, 'Gutschein-Aktion'),
         type: requireEnumKey(VoucherType, voucher.type, 'Gutscheinart'),
-        // Euro-Feld nur fuer Altbestand-Konsumenten des Backends — siehe Kommentar oben.
-        value: voucher.valueCents == null ? null : voucher.valueCents / 100,
         valueCents: voucher.valueCents ?? null,
+        ...(voucher.code != null ? { code: voucher.code } : {}),
+        ...(voucher.name != null ? { name: voucher.name } : {}),
     };
 }
 /**

package/dist/esm/partner/ablauf.d.ts

@@ -8,12 +8,12 @@
  * `signature_not_ready`).
  * Wer die Reihenfolge nur aus einer Fehlermeldung lernt, lernt sie einmal je
  * Fehler. Hier steht sie vorher — abfragbar, ausgebbar, und in
- * [naechsterSchritt] auch beantwortbar.
+ * [nextFlowStep] auch beantwortbar.
  *
  * **Kein eigener Vertragsschritt.** AVV und Nutzungsvertrag bestaetigt der
  * Betrieb ueber denselben Einrichtungs-Link wie seinen FinanzOnline-Zugang
  * (Schritt `fon`). Live geht ohne beide keine Kasse live
- * (`vertrag_offen`); den Stand zeigen `avv` und `terms` am Betrieb.
+ * (`contracts_pending`); den Stand zeigen `avv` und `terms` am Betrieb.
  *
  * Zwei Dinge laufen bewusst **parallel**: der Signaturantrag und das Anlegen
  * der Kasse. Eine mit `automatic:true` angelegte Kasse wartet, bis die
@@ -21,18 +21,18 @@
  * darum immer nur den **weitesten erreichten** Meilenstein, nicht die einzige
  * laufende Arbeit.
  */
-import type { KundenStatus } from './typen.js';
+import type { PartnerCustomerStatus } from './typen.js';
 /** Ein Schritt der Kette. */
-export interface AblaufSchritt {
+export interface FlowStep {
     key: string;
     /** Was in diesem Schritt passiert. */
     text: string;
     /** Der Aufruf, der ihn ausloest — `null`, wenn hier nur gewartet wird. */
-    aufruf: string | null;
+    call: string | null;
     /** Das Ereignis, das seinen Abschluss meldet — `null`, wenn es sofort feststeht. */
-    wartetAuf: string | null;
+    waitsFor: string | null;
     /** Der Fehlercode, mit dem ein spaeterer Aufruf sich beschwert, wenn dieser Schritt fehlt. */
-    fehltCode: string | null;
+    missingCode: string | null;
 }
 /**
  * Die Kette in ihrer Reihenfolge. Sie beschreibt den **Live-Weg**; mit einem
@@ -40,9 +40,9 @@ export interface AblaufSchritt {
  * ist sofort bereit (AT100-Testkarte — die damit erzeugten Belege sind keine
  * gueltigen RKSV-Belege).
  */
-export declare const PARTNER_ABLAUF: readonly AblaufSchritt[];
+export declare const PARTNER_FLOW: readonly FlowStep[];
 /**
  * Der Schritt, an dem ein Betrieb mit diesem Status steht — `null` fuer
- * `gesperrt` und fuer jeden Status, den dieses Paket nicht kennt.
+ * `blocked` und fuer jeden Status, den dieses Paket nicht kennt.
  */
-export declare function naechsterSchritt(status: KundenStatus): AblaufSchritt | null;
+export declare function nextFlowStep(status: PartnerCustomerStatus): FlowStep | null;