@kreiseck/kasseneck-api 0.29.0 → 0.30.0

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

@@ -0,0 +1,85 @@
+import { KeckPaymentMethod, type KeckPaymentMethodKey, CreditCardProvider } from '../enums/index.js';
+/**
+ * Eine Zahlung am Beleg — Zwilling der Eintraege in `payments`, wie
+ * `functions/gemeinsam/zahlungen-core.js` (`pruefeZahlungen`) sie normalisiert
+ * und ablegt.
+ *
+ * Ein Beleg kann ueber mehrere Zahlungen bezahlt sein (zwei Karten, Rest bar).
+ * Dann steht die Liste unter `payments`, und das Einzelfeld `paymentMethod`
+ * ist `mixed`, sobald verschiedene Zahlarten vorkommen (zwei Karten ergeben
+ * `creditCard`). Altbelege haben keine Liste; dort gilt weiter
+ * `paymentMethod` samt Kartenfeldern.
+ *
+ * Betraege in ganzen Cent: am Verkauf positiv, am Storno negativ (Rueckzahlung).
+ * `method`/`provider` sind beim Lesen wie ueberall entweder der bekannte
+ * Enum-Eintrag oder der rohe Schluessel (siehe `enum-payload.ts`).
+ */
+export interface ReceiptPayment {
+    /** Vom Server vergeben (`p1`, `p2`, …); Bezugspunkt fuer `refundOf`. */
+    id?: string;
+    method: KeckPaymentMethod | string;
+    amountCents: number;
+    /** Nur bei Barzahlung: gegebener Betrag. */
+    tenderedCents?: number;
+    /** Nur neben `tenderedCents`: Rueckgeld (vom Server gerechnet). */
+    changeCents?: number;
+    /** Kartenanbieter bzw. Terminal. */
+    provider?: CreditCardProvider | string;
+    /** Kennung der Zahlung am Terminal/Anbieter. */
+    providerPaymentId?: string;
+    /** Terminaldaten fuer den Kartenblock (frueher `cardPaymentData`). */
+    providerData?: Record<string, unknown>;
+    /** Nur am Storno: `id` der Originalzahlung, die erstattet wird. */
+    refundOf?: string;
+    /**
+     * Trinkgeld, das mit dieser Zahlung gegeben wurde, in ganzen Cent — TEIL
+     * von `amountCents` (das Terminal bucht Betrag + Trinkgeld zusammen). Nur
+     * an Verkaufs-/Trainingsbelegen.
+     */
+    tipCents?: number;
+}
+/** Nutzlast-Form einer Zahlung (Backend-Dokument bzw. Antwort). */
+export interface ReceiptPaymentPayload {
+    id?: string;
+    method: string;
+    amountCents: number;
+    tenderedCents?: number;
+    changeCents?: number;
+    provider?: string;
+    providerPaymentId?: string;
+    providerData?: Record<string, unknown>;
+    refundOf?: string;
+    tipCents?: number;
+}
+/**
+ * Eine Zahlung, wie der Aufrufer sie an `createReceipt`/`sellReceipt`/
+ * `cancelReceipt` schickt. `id` und `changeCents` vergibt der Server.
+ *
+ * - `method`: jede Zahlungsart ausser `mixed`.
+ * - `amountCents`: ganze Cent, am Verkauf > 0, am Storno < 0.
+ * - `tenderedCents`: nur bei Barzahlung am Verkauf, hoechstens an einer Zahlung.
+ * - `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.
+ * - `refundOf`: nur am Storno.
+ * - `tipCents`: Trinkgeld dieser Zahlung, ganze Cent > 0, Teil von
+ *   `amountCents`; nur am Verkauf, nie neben `tip` (den Rest prueft der Server).
+ */
+export interface ReceiptPaymentInput {
+    method: KeckPaymentMethod | KeckPaymentMethodKey;
+    amountCents: number;
+    tenderedCents?: number;
+    provider?: CreditCardProvider;
+    providerPaymentId?: string;
+    providerData?: Record<string, unknown>;
+    refundOf?: string;
+    tipCents?: number;
+}
+/** Lesepfad: nur vorhandene Felder uebernehmen, nichts ergaenzen. */
+export declare function fromReceiptPaymentPayload(payload: ReceiptPaymentPayload): ReceiptPayment;
+/**
+ * Schreibpfad: Zahlungen zurueck in die Nutzlast — streng wie
+ * `toReceiptPayload`: ein roher, unbekannter Schluessel bei `method` oder
+ * `provider` wirft.
+ */
+export declare function toReceiptPaymentPayload(payment: ReceiptPayment): ReceiptPaymentPayload;

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromReceiptPaymentPayload = fromReceiptPaymentPayload;
+exports.toReceiptPaymentPayload = toReceiptPaymentPayload;
+const index_js_1 = require("../enums/index.js");
+const enum_payload_js_1 = require("./enum-payload.js");
+/** Lesepfad: nur vorhandene Felder uebernehmen, nichts ergaenzen. */
+function fromReceiptPaymentPayload(payload) {
+    return {
+        ...(typeof payload.id === 'string' ? { id: payload.id } : {}),
+        method: (0, enum_payload_js_1.readEnumKey)(index_js_1.KeckPaymentMethod, payload.method),
+        amountCents: payload.amountCents,
+        ...(typeof payload.tenderedCents === 'number' ? { tenderedCents: payload.tenderedCents } : {}),
+        ...(typeof payload.changeCents === 'number' ? { changeCents: payload.changeCents } : {}),
+        ...(typeof payload.provider === 'string' ? { provider: (0, enum_payload_js_1.readEnumKey)(index_js_1.CreditCardProvider, payload.provider) } : {}),
+        ...(typeof payload.providerPaymentId === 'string' ? { providerPaymentId: payload.providerPaymentId } : {}),
+        ...(payload.providerData != null && typeof payload.providerData === 'object' ? { providerData: payload.providerData } : {}),
+        ...(typeof payload.refundOf === 'string' ? { refundOf: payload.refundOf } : {}),
+        ...(typeof payload.tipCents === 'number' ? { tipCents: payload.tipCents } : {}),
+    };
+}
+/**
+ * Schreibpfad: Zahlungen zurueck in die Nutzlast — streng wie
+ * `toReceiptPayload`: ein roher, unbekannter Schluessel bei `method` oder
+ * `provider` wirft.
+ */
+function toReceiptPaymentPayload(payment) {
+    return {
+        ...(payment.id !== undefined ? { id: payment.id } : {}),
+        method: typeof payment.method === 'object' ? payment.method.value : (0, enum_payload_js_1.requireEnumKey)(index_js_1.KeckPaymentMethod, payment.method, 'Zahlungsart').value,
+        amountCents: payment.amountCents,
+        ...(payment.tenderedCents !== undefined ? { tenderedCents: payment.tenderedCents } : {}),
+        ...(payment.changeCents !== undefined ? { changeCents: payment.changeCents } : {}),
+        ...(payment.provider !== undefined ? { provider: (0, enum_payload_js_1.requireEnumKey)(index_js_1.CreditCardProvider, payment.provider, 'Kartenanbieter') } : {}),
+        ...(payment.providerPaymentId !== undefined ? { providerPaymentId: payment.providerPaymentId } : {}),
+        ...(payment.providerData !== undefined ? { providerData: payment.providerData } : {}),
+        ...(payment.refundOf !== undefined ? { refundOf: payment.refundOf } : {}),
+        ...(payment.tipCents !== undefined ? { tipCents: payment.tipCents } : {}),
+    };
+}

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

@@ -1,4 +1,5 @@
 import { KeckPaymentMethod, ReceiptType } from '../enums/index.js';
+import { type ReceiptPayment, type ReceiptPaymentPayload } from './receipt-payment.js';
 /**
  * Belegzeile einer Liste — die Form, die `listMyReceipts` liefert
  * (`projectReceiptForCustomer` in functions/index.js).
@@ -63,6 +64,13 @@ export interface ReceiptSummary {
     stornoStand: 'offen' | 'teil' | 'voll';
     /** Nur am Nullbeleg, nur fuer Kassen-Benutzer: Anlass (monthly, annual, annual_replacement, outage_end, final, manual). */
     zeroKind?: ZeroKind;
+    /**
+     * Zahlungsliste, nur bei Belegen, die eine tragen. Die Liste liefert nur
+     * die oeffentlichen Felder (id, method, amountCents, provider,
+     * tenderedCents, changeCents, refundOf, tipCents) — Anbieter-Interna
+     * (`providerPaymentId`, `providerData`) bleiben im Backend.
+     */
+    payments?: ReceiptPayment[];
 }
 export interface ReceiptSummaryPayload {
     receiptId?: string | null;
@@ -90,5 +98,6 @@ export interface ReceiptSummaryPayload {
     cancellationReason?: string | null;
     stornoStand?: string | null;
     zeroKind?: string | null;
+    payments?: ReceiptPaymentPayload[] | null;
 }
 export declare function fromReceiptSummaryPayload(payload: ReceiptSummaryPayload): ReceiptSummary;

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

@@ -6,6 +6,7 @@ exports.fromReceiptSummaryPayload = fromReceiptSummaryPayload;
 const index_js_1 = require("../enums/index.js");
 const money_js_1 = require("../money.js");
 const enum_payload_js_1 = require("./enum-payload.js");
+const receipt_payment_js_1 = require("./receipt-payment.js");
 /**
  * Belegzeile einer Liste — die Form, die `listMyReceipts` liefert
  * (`projectReceiptForCustomer` in functions/index.js).
@@ -53,5 +54,6 @@ function fromReceiptSummaryPayload(payload) {
         ...(payload.cancellationReason ? { cancellationReason: payload.cancellationReason } : {}),
         stornoStand: payload.stornoStand === 'teil' || payload.stornoStand === 'voll' ? payload.stornoStand : 'offen',
         ...(istZeroKind(payload.zeroKind) ? { zeroKind: payload.zeroKind } : {}),
+        ...(Array.isArray(payload.payments) ? { payments: payload.payments.map(receipt_payment_js_1.fromReceiptPaymentPayload) } : {}),
     };
 }

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

@@ -3,6 +3,7 @@ import { type ReceiptItem, type ReceiptItemPayload, type ReceiptItemPayloadRead
 import { type Voucher, type VoucherPayload } from './voucher.js';
 import type { Cancellation, CancellationOf, CancellationReason } from './cancellation.js';
 import { type ZeroKind } from './receipt-summary.js';
+import { type ReceiptPayment, type ReceiptPaymentPayload } from './receipt-payment.js';
 /**
  * Beleg — Zwilling der Beleg-Nutzlast von `KasseneckReceipt` in
  * kasseneck_api/lib/models/kasseneck_receipt.dart (nur der signatur-/
@@ -54,6 +55,12 @@ export interface Receipt {
     cancellations?: Cancellation[];
     /** Nur an Nullbelegen: Anlass (monthly, annual, annual_replacement, outage_end, final, manual). */
     zeroKind?: ZeroKind;
+    /**
+     * Zahlungsliste (mehrere Zahlungen je Beleg), nur vorhanden, wenn der Beleg
+     * sie traegt. Altbelege haben keine; dort gelten `paymentMethod` und die
+     * Kartenfelder. Siehe [ReceiptPayment].
+     */
+    payments?: ReceiptPayment[];
 }
 export interface ReceiptPayload {
     qr: string;
@@ -78,6 +85,8 @@ export interface ReceiptPayload {
     customProjectId: string | null;
     /** Nur bei Belegen mit Trinkgeld (siehe [Receipt.tipCents]). */
     tipCents?: number | null;
+    /** Nur bei Belegen mit Zahlungsliste (siehe [Receipt.payments]). */
+    payments?: ReceiptPaymentPayload[] | null;
 }
 /**
  * Nutzlast-Form, die dieses Paket **liest**. Unterscheidet sich von

package/dist/cjs/models/receipt.js

@@ -9,6 +9,7 @@ const enum_payload_js_1 = require("./enum-payload.js");
 const receipt_item_js_1 = require("./receipt-item.js");
 const voucher_js_1 = require("./voucher.js");
 const receipt_summary_js_1 = require("./receipt-summary.js");
+const receipt_payment_js_1 = require("./receipt-payment.js");
 /**
  * Schreibt die Nutzlast in der **neuen** Form — sie **normalisiert, statt zu
  * spiegeln**: ein Beleg, der in der v1-Positionsform gelesen wurde, geht hier
@@ -49,6 +50,7 @@ function toReceiptPayload(receipt) {
         signatureSuccess: receipt.signatureSuccess ?? null,
         customProjectId: receipt.customProjectId ?? null,
         ...(receipt.tipCents != null ? { tipCents: receipt.tipCents } : {}),
+        ...(receipt.payments != null ? { payments: receipt.payments.map(receipt_payment_js_1.toReceiptPaymentPayload) } : {}),
     };
 }
 // Nullbelege haben keine Positionen -> items kann fehlen/null sein (siehe Dart-Vorbild).
@@ -84,6 +86,7 @@ function fromReceiptPayload(payload) {
         ...(payload.cancellationReason ? { cancellationReason: payload.cancellationReason } : {}),
         ...((0, receipt_summary_js_1.istZeroKind)(payload.zeroKind) ? { zeroKind: payload.zeroKind } : {}),
         ...(payload.cancellations ? { cancellations: payload.cancellations.map(leseStorno) } : {}),
+        ...(Array.isArray(payload.payments) ? { payments: payload.payments.map(receipt_payment_js_1.fromReceiptPaymentPayload) } : {}),
     };
 }
 function leseStorno(eintrag) {

package/dist/cjs/receipt/layout.js

@@ -303,16 +303,13 @@ function stripeBlock(daten, cardPaymentId) {
     return zeilen;
 }
 /**
- * Der Kartenzahlungsblock des Belegs -- fuer JEDEN Anbieter, den das Backend
- * kennt. Ohne `cardPaymentData` bleibt der Block weg; ein unbekannter Anbieter
- * ebenfalls, still und ohne Fehler: ein Beleg muss sich immer zeigen lassen.
+ * Der Kartenzahlungsblock eines Anbieters -- fuer JEDEN Anbieter, den das
+ * Backend kennt. Ein unbekannter Anbieter bekommt keinen Block, still und
+ * ohne Fehler: ein Beleg muss sich immer zeigen lassen.
  */
-function kartenblock(receipt) {
-    const daten = receipt.cardPaymentData;
-    if (daten == null)
-        return [];
+function anbieterBlock(provider, daten, id) {
     const zeilen = (() => {
-        switch (receipt.creditCardProvider) {
+        switch (provider) {
             case 'hobexHps':
             case 'hobexCloudApi':
                 return hobexBlock(daten);
@@ -324,7 +321,7 @@ function kartenblock(receipt) {
             case 'myposPro':
                 return myposBlock(daten);
             case 'stripe':
-                return stripeBlock(daten, receipt.cardPaymentId ?? null);
+                return stripeBlock(daten, id);
             default:
                 return [];
         }
@@ -337,12 +334,117 @@ function kartenblock(receipt) {
     // gehoert aber zum Blatt, nicht zum Terminal.
     return [...zeilen, { kind: 'space', lines: 1 }];
 }
+/**
+ * Die Kartenzahlungsbloecke des Belegs. Mit Zahlungsliste (`payments`) je
+ * Zahlung mit Anbieter und Terminaldaten ein Block, in Zahlungsreihenfolge --
+ * zwei Karten desselben Anbieters ergeben zwei Bloecke; die alten
+ * Einzelfelder zaehlen dann nicht. Bei mehreren Zahlungen steht vor jedem
+ * Block, nicht fett und zentriert, die Nummer der Zahlung aus der
+ * Aufschluesselung („2. Kartenzahlung") -- so ist jeder Block seiner Zeile
+ * zuzuordnen. Ohne (oder mit leerer) Liste der bisherige Weg ueber
+ * `creditCardProvider`/`cardPaymentData`/`cardPaymentId` -- ebenso bei
+ * hoechstens einer Zahlung ohne `providerData`, wenn die Altfelder gesetzt sind.
+ */
+function kartenblock(receipt) {
+    const zahlungen = receipt.payments;
+    // Eine einzelne Zahlung ohne Terminaldaten neben gesetzten Altfeldern
+    // (creditCardProvider + cardPaymentData): der bisherige Block, wie ohne Liste.
+    const altfelderTragen = zahlungen != null && zahlungen.length <= 1
+        && zahlungen.every((z) => z.providerData == null)
+        && receipt.creditCardProvider != null && receipt.cardPaymentData != null;
+    if (zahlungen != null && zahlungen.length > 0 && !altfelderTragen) {
+        const zeilen = [];
+        zahlungen.forEach((zahlung, i) => {
+            if (zahlung.provider == null || zahlung.providerData == null)
+                return;
+            const block = anbieterBlock(zahlung.provider, zahlung.providerData, zahlung.providerPaymentId ?? null);
+            if (block.length === 0)
+                return;
+            if (zahlungen.length > 1)
+                zeilen.push(textZeile(zahlungNummerText(zahlung, i), 'center'));
+            zeilen.push(...block);
+        });
+        return zeilen;
+    }
+    const daten = receipt.cardPaymentData;
+    if (daten == null)
+        return [];
+    return anbieterBlock(receipt.creditCardProvider, daten, receipt.cardPaymentId ?? null);
+}
 function zahlungsartText(wert) {
     if (wert != null && typeof wert === 'object') {
         return wert.label;
     }
     return typeof wert === 'string' ? wert : '';
 }
+/** Barzahlarten -- Zwilling von `BAR_ZAHLARTEN` (functions/gemeinsam/tip-core.js). */
+const BAR_ZAHLARTEN = ['cash', 'uberCash', 'boltCash'];
+function zahlartSchluessel(wert) {
+    if (wert != null && typeof wert === 'object')
+        return wert.value;
+    return typeof wert === 'string' ? wert : '';
+}
+/**
+ * Nummerierter Text einer Zahlung („1. Kartenzahlung", „3. Barzahlung") --
+ * in der Aufschluesselung und ueber ihrem Kartenblock dieselbe Nummer, in
+ * Zahlungsreihenfolge ab 1.
+ */
+function zahlungNummerText(zahlung, index) {
+    return `${index + 1}. ${zahlungsartText(zahlung.method)}`;
+}
+/** „davon Trinkgeld" eingerueckt unter einer Zahlung, die Trinkgeld traegt. */
+function zahlungTrinkgeldZeilen(zahlung) {
+    if (typeof zahlung.tipCents !== 'number' || zahlung.tipCents <= 0)
+        return [];
+    return [paarZeile('  davon Trinkgeld', `${formatCents(zahlung.tipCents)} €`, 8, 4)];
+}
+/**
+ * Gegeben/Rueckgeld unter einer Barzahlung mit `tenderedCents`. Fehlt
+ * `changeCents` (der Server rechnet es sonst selbst), ergibt es sich aus
+ * gegeben minus Betrag.
+ */
+function barZeilen(zahlung) {
+    if (!BAR_ZAHLARTEN.includes(zahlartSchluessel(zahlung.method)) || typeof zahlung.tenderedCents !== 'number')
+        return [];
+    const rueckgeld = typeof zahlung.changeCents === 'number' ? zahlung.changeCents : zahlung.tenderedCents - zahlung.amountCents;
+    return [
+        paarZeile('  Gegeben:', `${formatCents(zahlung.tenderedCents)} €`, 8, 4),
+        paarZeile('  Rückgeld:', `${formatCents(rueckgeld)} €`, 8, 4),
+    ];
+}
+/**
+ * Die Zahlungszeilen unter „Gesamt:".
+ *
+ * - Ohne Zahlungsliste: „Zahlungsart: <Label>" aus `paymentMethod`, wie immer.
+ * - Genau eine Zahlung: dieselbe Zeile, Label aus der Zahlung.
+ * - Mehrere Zahlungen (auch zwei Karten, die `paymentMethod: creditCard`
+ *   ergeben -- entschieden wird an der Laenge, nie an `mixed`): „Zahlungsarten:"
+ *   und je Zahlung eine nummerierte Zeile mit Betrag, ohne Anbieter (der
+ *   steht im Kartenblock mit derselben Nummer). Breite 8:4 -- auf 58 mm
+ *   bleiben der Betragsspalte elf Zeichen, genug fuer „-9999,99 €".
+ *
+ * Unter jeder Zahlung in dieser Reihenfolge: „davon Trinkgeld" (bei
+ * `tipCents`), dann bei einer Barzahlung mit gegebenem Betrag „Gegeben:" und
+ * „Rückgeld:" -- alles, was zu einer Zahlung gehoert, zwei Zeichen eingerueckt,
+ * die Zahlung selbst buendig.
+ */
+function zahlungsZeilen(receipt) {
+    const zahlungen = receipt.payments;
+    if (zahlungen == null || zahlungen.length === 0) {
+        return [paarZeile('Zahlungsart:', zahlungsartText(receipt.paymentMethod))];
+    }
+    if (zahlungen.length === 1) {
+        const zahlung = zahlungen[0];
+        return [paarZeile('Zahlungsart:', zahlungsartText(zahlung.method)), ...zahlungTrinkgeldZeilen(zahlung), ...barZeilen(zahlung)];
+    }
+    const zeilen = [textZeile('Zahlungsarten:')];
+    zahlungen.forEach((zahlung, i) => {
+        zeilen.push(paarZeile(zahlungNummerText(zahlung, i), `${formatCents(zahlung.amountCents)} €`, 8, 4));
+        zeilen.push(...zahlungTrinkgeldZeilen(zahlung));
+        zeilen.push(...barZeilen(zahlung));
+    });
+    return zeilen;
+}
 // -------------------------------------------------------- Kleinunternehmer
 /**
  * Hinweis auf die Steuerbefreiung, den ein Kleinunternehmerbeleg tragen muss —
@@ -910,7 +1012,7 @@ function buildReceiptLayout(receipt, company, options = {}) {
         lines.push({ kind: 'rule', char: '-' });
     }
     lines.push(paarZeile('Gesamt:', `${formatCents(summeCents)} €`));
-    lines.push(paarZeile('Zahlungsart:', zahlungsartText(receipt.paymentMethod)));
+    lines.push(...zahlungsZeilen(receipt));
     lines.push({ kind: 'space', lines: 1 });
     // --- Rechtshinweise und Ausfallhinweis
     const hinweise = company.isSmallBusiness

package/dist/esm/client/api.d.ts

@@ -3,7 +3,7 @@ import { type CreateStripeLinkOptions, type StripeCaptureResult } from '../payme
 import { type HobexPayOptions, type HobexRefundOptions } from '../payments/hobex.js';
 import { type TransportOptions } from './transport.js';
 import { type CashboxStatus, type SignatureStatus } from './status.js';
-import { type SendReceiptEmailOptions, type SendReceiptEmailResult, type ListMyReceiptsOptions, type ReceiptList, type ReceiptWithCompany, type SellReceiptOptions, type CancelReceiptOptions, type CancelReceiptResult, type CreateCancelReceiptOptions } from './receipts.js';
+import { type SendReceiptEmailOptions, type SendReceiptEmailResult, type ListMyReceiptsOptions, type ReceiptList, type ReceiptWithCompany, type SellReceiptOptions, type SellReceiptWithPaymentsOptions, type CancelReceiptOptions, type CancelReceiptResult, type CreateCancelReceiptOptions } from './receipts.js';
 /**
  * Schlichte Factory ueber den Endpunkt-Funktionen: bindet einen Transport
  * einmal und liefert die Aufrufe ohne den wiederkehrenden ersten Parameter.
@@ -30,9 +30,9 @@ import { type SendReceiptEmailOptions, type SendReceiptEmailResult, type ListMyR
  */
 export interface KasseneckApi {
     /** Normalbeleg (Verkauf). */
-    sellReceipt(options: SellReceiptOptions): Promise<Receipt>;
+    sellReceipt(options: SellReceiptOptions | SellReceiptWithPaymentsOptions): Promise<Receipt>;
     /** Normalbeleg samt Firmen-/Druckdaten fuer den Belegdruck. */
-    sellReceiptWithCompany(options: SellReceiptOptions): Promise<ReceiptWithCompany>;
+    sellReceiptWithCompany(options: SellReceiptOptions | SellReceiptWithPaymentsOptions): Promise<ReceiptWithCompany>;
     /** Storno eines bestehenden Belegs — voll oder in Teilen, ueber den Storno-Endpunkt. */
     cancelReceipt(options: CancelReceiptOptions): Promise<CancelReceiptResult>;
     /** Storno aus frei uebergebenen Positionen. */

package/dist/esm/client/index.d.ts

@@ -2,7 +2,7 @@ export { type AuthCredentials, type KasseneckAuth, type ApiKeyAuthOptions, type
 export { DEFAULT_BASE_URL, DEFAULT_TIMEOUT_MS, type HttpResponseLike, type HttpRequestInit, type FetchLike, type TransportOptions, type TransportBodyFields, type KasseneckTransport, type KasseneckBinaryTransport, createTransport, createBinaryTransport, } from './transport.js';
 export { AUFRUFE, type Aufruf, } from './aufrufe.js';
 export { KasseneckApiError, KasseneckAuthError, KasseneckHttpError, KasseneckNetworkError, KasseneckValidationError, type ValidationScope, type KasseneckError, type HttpFailureReason, type CauseDigest, isKasseneckApiError, isKasseneckAuthError, isKasseneckHttpError, isKasseneckNetworkError, isKasseneckValidationError, } from './errors.js';
-export { type ReceiptCommonOptions, type SellReceiptOptions, type TipOptions, type TipRecipientShare, type CancelReceiptOptions, type CreateCancelReceiptOptions, type ReceiptWithCompany, sellReceipt, sellReceiptWithCompany, cancelReceipt, type CancelReceiptResult, createCancelReceipt, zeroReceipt, getReceipt, getReceiptWithCompany, generateFullReceiptId, getFirstReceiptDate, listMyReceipts, type ListMyReceiptsOptions, type ReceiptList, type ReceiptListStats, checkVoucherCombinationError, type SendReceiptEmailOptions, type SendReceiptEmailResult, sendReceiptEmail, } from './receipts.js';
+export { type ReceiptCommonOptions, type SellReceiptOptions, type SellReceiptWithPaymentsOptions, type TipOptions, type TipRecipientShare, type CancelReceiptOptions, type CreateCancelReceiptOptions, type ReceiptWithCompany, sellReceipt, sellReceiptWithCompany, cancelReceipt, type CancelReceiptResult, createCancelReceipt, zeroReceipt, getReceipt, getReceiptWithCompany, generateFullReceiptId, getFirstReceiptDate, listMyReceipts, type ListMyReceiptsOptions, type ReceiptList, type ReceiptListStats, checkVoucherCombinationError, type SendReceiptEmailOptions, type SendReceiptEmailResult, sendReceiptEmail, } from './receipts.js';
 export { listMyCashregisters } from './cashregisters.js';
 export { downloadDailyReport, downloadMonthlyReport } from './reports.js';
 export { type CashboxStatus, type SignatureStatus, getCashboxStatus, getSignatureStatus, } from './status.js';

package/dist/esm/client/receipts.d.ts

@@ -1,5 +1,5 @@
 import { ReceiptType, type ReceiptTypeKey, KeckPaymentMethod, type KeckPaymentMethodKey, CreditCardProvider } from '../enums/index.js';
-import { type Receipt, type ReceiptCompany, type ReceiptItem, type Voucher, type ReceiptSummary, type ReportMonth, type CancellationItem, type CancellationOf, type CancellationReason } from '../models/index.js';
+import { type Receipt, type ReceiptCompany, type ReceiptItem, type Voucher, type ReceiptSummary, type ReportMonth, type CancellationItem, type CancellationOf, type CancellationReason, type ReceiptPaymentInput } from '../models/index.js';
 import type { InternerTransport } from './aufrufe.js';
 import type { Pruefangaben, ReceiptLayout } from '../receipt/layout.js';
 import type { LogoStufe } from '../receipt/blatt.js';
@@ -90,11 +90,32 @@ export interface CreateReceiptOptions extends ReceiptCommonOptions {
      * ausdruecklich uebergebene `paymentMethod` sticht.
      */
     paymentMethodFromServer?: string;
+    /**
+     * Mehrere Zahlungen je Beleg (siehe [ReceiptPaymentInput]). Schliesst
+     * `paymentMethod`, `paymentMethodFromServer` und die Kartenfelder aus —
+     * die Kartenangaben gehoeren dann in die einzelne Zahlung (Backend:
+     * `PAYMENTS_CONFLICT`). Nur bei `standard` und `training`.
+     */
+    payments?: ReceiptPaymentInput[];
     items?: ReceiptItem[];
     vouchers?: Voucher[];
 }
+/** Verkauf mit einer Zahlungsart (`paymentMethod`, Kartenfelder aus [ReceiptCommonOptions]). */
 export interface SellReceiptOptions extends ReceiptCommonOptions {
     paymentMethod: KeckPaymentMethod | KeckPaymentMethodKey;
+    payments?: undefined;
+    items?: ReceiptItem[];
+    vouchers?: Voucher[];
+}
+/**
+ * Verkauf mit mehreren Zahlungen (`payments`, siehe [ReceiptPaymentInput]).
+ * Ohne `paymentMethod` und ohne die Kartenfelder aus [ReceiptCommonOptions] —
+ * die Kartenangaben stehen in der einzelnen Zahlung (Backend:
+ * `PAYMENTS_CONFLICT`, zur Laufzeit ebenso geprueft).
+ */
+export interface SellReceiptWithPaymentsOptions extends ReceiptCommonOptions {
+    payments: ReceiptPaymentInput[];
+    paymentMethod?: undefined;
     items?: ReceiptItem[];
     vouchers?: Voucher[];
 }
@@ -126,6 +147,14 @@ export type CancelReceiptOptions = {
     creditCardProvider?: CreditCardProvider;
     cardPaymentId?: string;
     cardPaymentData?: Record<string, unknown>;
+    /**
+     * Rueckzahlung je Zahlung (Betraege negativ, `refundOf` = `id` der
+     * Originalzahlung). Schliesst `paymentMethod` und die Kartenfelder aus
+     * (Backend: `PAYMENTS_CONFLICT`). Ohne Angabe spiegelt der Server die
+     * Restbetraege jeder Originalzahlung; ein Teilstorno eines Belegs mit
+     * mehreren Zahlungen braucht sie (`STORNO_PAYMENTS_REQUIRED`).
+     */
+    payments?: ReceiptPaymentInput[];
 } & ({
     receipt: Receipt;
     cashregisterId?: string;
@@ -183,12 +212,12 @@ export interface ReceiptWithCompany {
  */
 export declare function createReceipt(rufen: InternerTransport, options: CreateReceiptOptions): Promise<Receipt>;
 /** Normalbeleg (Verkauf) nach RKSV. */
-export declare function sellReceipt(rufen: InternerTransport, options: SellReceiptOptions): Promise<Receipt>;
+export declare function sellReceipt(rufen: InternerTransport, options: SellReceiptOptions | SellReceiptWithPaymentsOptions): Promise<Receipt>;
 /**
  * Normalbeleg wie [sellReceipt], liefert zusaetzlich die Firmen-/Druckdaten
  * aus derselben Antwort — alles, was ein Belegdruck braucht, in einem Aufruf.
  */
-export declare function sellReceiptWithCompany(rufen: InternerTransport, options: SellReceiptOptions): Promise<ReceiptWithCompany>;
+export declare function sellReceiptWithCompany(rufen: InternerTransport, options: SellReceiptOptions | SellReceiptWithPaymentsOptions): Promise<ReceiptWithCompany>;
 /**
  * Storno-Beleg zu einem bestehenden Beleg — voll oder in Teilen. Prueft die
  * Eingabe, bevor etwas hinausgeht; der Server haelt die Restmengen und die

package/dist/esm/client/receipts.js

@@ -50,6 +50,22 @@ function createReceiptParams(options) {
     if (items != null && items.length > 0) {
         params['items'] = alsNutzlast(items, toReceiptItemPayload);
     }
+    // `payments: null` gilt wie im Backend (zahlungs-eingang.js) als nicht angegeben.
+    if (options.payments != null) {
+        // Der alte Storno-Weg und der Null-/Startbeleg nehmen keine Zahlungsliste
+        // (Backend: PAYMENTS_NOT_ALLOWED); ein Storno mit mehreren Zahlungen
+        // laeuft ueber cancelReceipt.
+        if (typ.value === ReceiptType.cancellation.value) {
+            throw eingabefehler('payments am Storno gehen nur ueber cancelReceipt.');
+        }
+        if (typ.value !== ReceiptType.standard.value && typ.value !== ReceiptType.training.value) {
+            throw eingabefehler(`payments sind bei receiptType "${typ.value}" nicht erlaubt.`);
+        }
+        const konflikt = zahlungsKonflikt(options);
+        if (konflikt != null)
+            throw eingabefehler(konflikt);
+        params['payments'] = gepruefteZahlungen(options.payments, false, 'createReceipt');
+    }
     // Vom Aufrufer kommt sie geprueft, vom Server roh — siehe die beiden Felder
     // in [CreateReceiptOptions]. Die Typpruefung allein reicht dafuer nicht: ein
     // Verbraucher ohne Typen faellt durch dieses Netz, und ein Tippfehler in der
@@ -133,11 +149,15 @@ export async function cancelReceipt(rufen, options) {
     if (options.note !== undefined && options.note.length > NOTE_MAX) {
         throw new KasseneckValidationError('cancelReceipt', `Anmerkung ist zu lang (hoechstens ${NOTE_MAX} Zeichen)`, 'request');
     }
+    // `payments: null` gilt wie im Backend als nicht angegeben.
+    const zahlungen = options.payments != null ? gepruefteStornoZahlungen(options) : undefined;
     const params = { cashregisterId, originalReceiptId, reason: options.reason };
     if (options.items !== undefined)
         params.items = options.items.map((p) => ({ index: p.index, quantity: p.quantity }));
     if (options.note !== undefined && options.note !== '')
         params.note = options.note;
+    if (zahlungen !== undefined)
+        params.payments = zahlungen;
     if (options.paymentMethod != null)
         params.paymentMethod = gepruefteZahlungsart(options.paymentMethod);
     const karte = options.creditCardProvider != null || options.cardPaymentId != null || options.cardPaymentData != null;
@@ -491,15 +511,110 @@ function gepruefterTip(tip) {
     }
     return nutzlast;
 }
-/** Zahlungsart des Aufrufers pruefen — unbekannt wirft, bevor etwas rausgeht. */
+/**
+ * Zahlungsart des Aufrufers pruefen — unbekannt wirft, bevor etwas rausgeht.
+ * `mixed` wirft ebenfalls: den Wert vergibt nur der Server (Beleg mit
+ * mehreren Zahlarten); gesendet wird stattdessen die Zahlungsliste.
+ */
 function gepruefteZahlungsart(wert) {
-    if (typeof wert === 'object') {
-        return wert.value;
+    let zahlungsart;
+    if (typeof wert === 'object' && wert !== null) {
+        zahlungsart = wert.value;
+    }
+    else {
+        if (typeof wert !== 'string' || !Object.prototype.hasOwnProperty.call(KeckPaymentMethod, wert)) {
+            throw eingabefehler(`Zahlungsart: unbekannter Schluessel "${String(wert)}"`);
+        }
+        zahlungsart = KeckPaymentMethod[wert].value;
     }
-    if (!Object.prototype.hasOwnProperty.call(KeckPaymentMethod, wert)) {
-        throw eingabefehler(`Zahlungsart: unbekannter Schluessel "${wert}"`);
+    if (zahlungsart === KeckPaymentMethod.mixed.value) {
+        throw eingabefehler('Zahlungsart "mixed" vergibt nur der Server – mehrere Zahlarten gehen als payments hinaus.');
     }
-    return KeckPaymentMethod[wert].value;
+    return zahlungsart;
+}
+/** Hoechstzahl der Zahlungen je Beleg (Backend: MAX_ZAHLUNGEN). */
+const MAX_ZAHLUNGEN = 20;
+/**
+ * `payments` neben einer Einzel-Zahlungsart oder Kartenfeldern? Liefert den
+ * Grund (Backend: PAYMENTS_CONFLICT), sonst null. Nie still eines bevorzugen.
+ */
+function zahlungsKonflikt(options) {
+    for (const feld of ['paymentMethod', 'paymentMethodFromServer', 'creditCardProvider', 'cardPaymentId', 'cardPaymentData']) {
+        if (options[feld] != null) {
+            return `payments und ${feld} duerfen nicht gemeinsam gesendet werden – Kartenangaben gehoeren in die Zahlung.`;
+        }
+    }
+    return null;
+}
+/**
+ * Zahlungsliste pruefen und in Nutzlast-Form bringen — Formpruefung wie
+ * `pruefeZahlungen` im Backend, soweit sie ohne Beleg und Zahlbetrag geht
+ * (Summe, Anbieter-Pflicht und Trinkgeld prueft der Server). Wirft, bevor
+ * etwas hinausgeht.
+ */
+function gepruefteZahlungen(roh, storno, functionName) {
+    const fehler = (grund) => new KasseneckValidationError(functionName, grund, 'request');
+    if (!Array.isArray(roh))
+        throw fehler('payments muss eine Liste sein.');
+    if (roh.length > MAX_ZAHLUNGEN)
+        throw fehler(`payments: es sind hoechstens ${MAX_ZAHLUNGEN} Eintraege erlaubt.`);
+    return roh.map((eintrag, i) => {
+        const nr = i + 1;
+        if (eintrag == null || typeof eintrag !== 'object' || Array.isArray(eintrag)) {
+            throw fehler(`Zahlung ${nr}: kein gueltiges Objekt.`);
+        }
+        const z = eintrag;
+        const method = gepruefteZahlungsart(z['method']);
+        const betrag = z['amountCents'];
+        if (typeof betrag !== 'number' || !Number.isInteger(betrag) || (storno ? betrag >= 0 : betrag <= 0)) {
+            throw fehler(`Zahlung ${nr}: amountCents muss eine ganze Zahl ${storno ? 'kleiner' : 'groesser'} als 0 sein.`);
+        }
+        const aus = { method, amountCents: betrag };
+        if (z['tenderedCents'] !== undefined) {
+            const gegeben = z['tenderedCents'];
+            if (storno || typeof gegeben !== 'number' || !Number.isInteger(gegeben) || gegeben < betrag) {
+                throw fehler(`Zahlung ${nr}: tenderedCents muss eine ganze Zahl von mindestens amountCents sein (nur am Verkauf).`);
+            }
+            aus['tenderedCents'] = gegeben;
+        }
+        if (z['tipCents'] !== undefined) {
+            const trinkgeld = z['tipCents'];
+            if (typeof trinkgeld !== 'number' || !Number.isInteger(trinkgeld) || trinkgeld <= 0) {
+                throw fehler(`Zahlung ${nr}: tipCents muss eine ganze Zahl groesser als 0 sein.`);
+            }
+            aus['tipCents'] = trinkgeld;
+        }
+        if (z['provider'] !== undefined) {
+            aus['provider'] = kartenanbieter(String(z['provider']));
+        }
+        if (z['providerPaymentId'] !== undefined) {
+            if (typeof z['providerPaymentId'] !== 'string' || z['providerPaymentId'] === '') {
+                throw fehler(`Zahlung ${nr}: providerPaymentId muss ein nicht-leerer Text sein.`);
+            }
+            aus['providerPaymentId'] = z['providerPaymentId'];
+        }
+        if (z['providerData'] !== undefined) {
+            const daten = z['providerData'];
+            if (daten === null || typeof daten !== 'object' || Array.isArray(daten)) {
+                throw fehler(`Zahlung ${nr}: providerData muss ein Objekt sein.`);
+            }
+            aus['providerData'] = daten;
+        }
+        if (z['refundOf'] !== undefined) {
+            if (!storno || typeof z['refundOf'] !== 'string' || z['refundOf'] === '') {
+                throw fehler(`Zahlung ${nr}: refundOf gibt es nur am Storno, als id der Originalzahlung.`);
+            }
+            aus['refundOf'] = z['refundOf'];
+        }
+        return aus;
+    });
+}
+/** `payments` am Storno: Konflikt mit Zahlungsart/Kartenfeldern, dann Form. */
+function gepruefteStornoZahlungen(options) {
+    const konflikt = zahlungsKonflikt(options);
+    if (konflikt != null)
+        throw new KasseneckValidationError('cancelReceipt', konflikt, 'request');
+    return gepruefteZahlungen(options.payments, true, 'cancelReceipt');
 }
 /** Kartenanbieter pruefen — er stammt vom Aufrufer, nicht aus Serverdaten. */
 function kartenanbieter(wert) {