@kreiseck/kasseneck-api 0.29.0 → 0.30.0

package/dist/esm/enums/keck-payment-method.d.ts

@@ -5,6 +5,11 @@
  * `label` ist das deutsche Anzeige-Label fuer die Zahlungsart-Zeile auf dem Beleg.
  * Muss 1:1 mit dem Backend-Mapping `paymentMethodToString` (functions/helper.js)
  * uebereinstimmen.
+ *
+ * `mixed` vergibt nur der Server: ein Beleg mit mehreren Zahlungen
+ * verschiedener Zahlart (`payments`) traegt ihn als Einzelfeld
+ * `paymentMethod`. Lesen ist erlaubt, Senden nicht — wer mehrere Zahlarten
+ * kassiert, schickt die Zahlungsliste, nie `mixed`.
  */
 export declare const KeckPaymentMethod: {
     readonly cash: {
@@ -52,6 +57,11 @@ export declare const KeckPaymentMethod: {
         readonly needsCreditCard: true;
         readonly label: "Bolt Card";
     };
+    readonly mixed: {
+        readonly value: "mixed";
+        readonly needsCreditCard: false;
+        readonly label: "Mehrere Zahlungsarten";
+    };
 };
 export type KeckPaymentMethodKey = keyof typeof KeckPaymentMethod;
 export type KeckPaymentMethod = (typeof KeckPaymentMethod)[KeckPaymentMethodKey];

package/dist/esm/enums/keck-payment-method.js

@@ -6,6 +6,11 @@ import { defineEnum } from './define-enum.js';
  * `label` ist das deutsche Anzeige-Label fuer die Zahlungsart-Zeile auf dem Beleg.
  * Muss 1:1 mit dem Backend-Mapping `paymentMethodToString` (functions/helper.js)
  * uebereinstimmen.
+ *
+ * `mixed` vergibt nur der Server: ein Beleg mit mehreren Zahlungen
+ * verschiedener Zahlart (`payments`) traegt ihn als Einzelfeld
+ * `paymentMethod`. Lesen ist erlaubt, Senden nicht — wer mehrere Zahlarten
+ * kassiert, schickt die Zahlungsliste, nie `mixed`.
  */
 export const KeckPaymentMethod = defineEnum({
     cash: { value: 'cash', needsCreditCard: false, label: 'Barzahlung' },
@@ -17,4 +22,5 @@ export const KeckPaymentMethod = defineEnum({
     boltApp: { value: 'boltApp', needsCreditCard: false, label: 'Bolt App' },
     boltCash: { value: 'boltCash', needsCreditCard: false, label: 'Bolt Cash' },
     boltCard: { value: 'boltCard', needsCreditCard: true, label: 'Bolt Card' },
+    mixed: { value: 'mixed', needsCreditCard: false, label: 'Mehrere Zahlungsarten' },
 });

package/dist/esm/index.d.ts

@@ -1,5 +1,5 @@
 export { ReceiptType, type ReceiptTypeKey, VatRate, type VatRateKey, KeckPaymentMethod, type KeckPaymentMethodKey, CreditCardProvider, type CreditCardProviderKey, VoucherType, type VoucherTypeKey, VoucherAction, type VoucherActionKey, StripeLinkMode, type StripeLinkModeKey, } from './enums/index.js';
-export { type ReceiptItem, type ReceiptItemPayload, type ReceiptItemPayloadRead, toReceiptItemPayload, fromReceiptItemPayload, receiptItemTotalCents, receiptItemIsValid, negateReceiptItem, type TipRecipient, isTipItem, type Voucher, type VoucherPayload, toVoucherPayload, fromVoucherPayload, voucherIsValid, type Receipt, type ReceiptPayload, type ReceiptPayloadRead, toReceiptPayload, fromReceiptPayload, receiptSubSumCents, receiptSumCents, type CancellationOf, type CancellationItem, type Cancellation, type CancellationReason, type CancellationErrorCode, CANCELLATION_REASONS, CANCELLATION_ERROR_CODES, CANCELLATION_RESERVATION_MS, isCancellationReason, isCancellationErrorCode, type ReceiptEmailErrorCode, RECEIPT_EMAIL_ERROR_CODES, isReceiptEmailErrorCode, remainingQuantities, type ReceiptCompany, type ReceiptCompanyPayload, fromReceiptCompanyPayload, receiptCompanyTaxInfo, type Cashregister, type CashregisterOnboarding, type CashregisterPayload, type CashregisterOnboardingPayload, fromCashregisterPayload, type ReceiptSummary, type ReceiptSummaryPayload, fromReceiptSummaryPayload, type ZeroKind, ZERO_KINDS, istZeroKind, type ReportMonth, reportMonthFromDate, previousReportMonth, nextReportMonth, reportMonthKey, reportMonthReadable, type StripeUrlSession, type StripeUrlSessionPayload, toStripeUrlSessionPayload, fromStripeUrlSessionPayload, type HobexReceipt, type HobexReceiptPayload, toHobexReceiptPayload, fromHobexReceiptPayload, hobexReceiptToCardPaymentData, hobexReceiptNeedsSignature, } from './models/index.js';
-export { type AuthCredentials, type KasseneckAuth, type ApiKeyAuthOptions, type RegisterUserAuthOptions, apiKeyAuth, registerUserAuth, DEFAULT_BASE_URL, DEFAULT_TIMEOUT_MS, type HttpResponseLike, type HttpRequestInit, type FetchLike, type TransportOptions, type TransportBodyFields, type KasseneckTransport, type KasseneckBinaryTransport, AUFRUFE, type Aufruf, createTransport, createBinaryTransport, KasseneckApiError, KasseneckAuthError, KasseneckHttpError, KasseneckNetworkError, KasseneckValidationError, type ValidationScope, type KasseneckError, type HttpFailureReason, type CauseDigest, isKasseneckApiError, isKasseneckAuthError, isKasseneckHttpError, isKasseneckNetworkError, isKasseneckValidationError, type ReceiptCommonOptions, type SellReceiptOptions, type TipOptions, type TipRecipientShare, type CancelReceiptOptions, type CancelReceiptResult, type CreateCancelReceiptOptions, type ReceiptWithCompany, sellReceipt, sellReceiptWithCompany, cancelReceipt, createCancelReceipt, zeroReceipt, getReceipt, getReceiptWithCompany, generateFullReceiptId, getFirstReceiptDate, listMyReceipts, type ListMyReceiptsOptions, type ReceiptList, type ReceiptListStats, listMyCashregisters, checkVoucherCombinationError, type SendReceiptEmailOptions, type SendReceiptEmailResult, sendReceiptEmail, downloadDailyReport, downloadMonthlyReport, type CashboxStatus, type SignatureStatus, getCashboxStatus, getSignatureStatus, type KasseneckApi, createKasseneckApi, } from './client/index.js';
+export { type ReceiptItem, type ReceiptItemPayload, type ReceiptItemPayloadRead, toReceiptItemPayload, fromReceiptItemPayload, receiptItemTotalCents, receiptItemIsValid, negateReceiptItem, type TipRecipient, isTipItem, type Voucher, type VoucherPayload, toVoucherPayload, fromVoucherPayload, voucherIsValid, type Receipt, type ReceiptPayload, type ReceiptPayloadRead, toReceiptPayload, fromReceiptPayload, receiptSubSumCents, receiptSumCents, type CancellationOf, type CancellationItem, type Cancellation, type CancellationReason, type CancellationErrorCode, CANCELLATION_REASONS, CANCELLATION_ERROR_CODES, CANCELLATION_RESERVATION_MS, isCancellationReason, isCancellationErrorCode, type ReceiptPayment, type ReceiptPaymentPayload, type ReceiptPaymentInput, fromReceiptPaymentPayload, toReceiptPaymentPayload, type PaymentErrorCode, PAYMENT_ERROR_CODES, isPaymentErrorCode, type ReceiptEmailErrorCode, RECEIPT_EMAIL_ERROR_CODES, isReceiptEmailErrorCode, remainingQuantities, type ReceiptCompany, type ReceiptCompanyPayload, fromReceiptCompanyPayload, receiptCompanyTaxInfo, type Cashregister, type CashregisterOnboarding, type CashregisterPayload, type CashregisterOnboardingPayload, fromCashregisterPayload, type ReceiptSummary, type ReceiptSummaryPayload, fromReceiptSummaryPayload, type ZeroKind, ZERO_KINDS, istZeroKind, type ReportMonth, reportMonthFromDate, previousReportMonth, nextReportMonth, reportMonthKey, reportMonthReadable, type StripeUrlSession, type StripeUrlSessionPayload, toStripeUrlSessionPayload, fromStripeUrlSessionPayload, type HobexReceipt, type HobexReceiptPayload, toHobexReceiptPayload, fromHobexReceiptPayload, hobexReceiptToCardPaymentData, hobexReceiptNeedsSignature, } from './models/index.js';
+export { type AuthCredentials, type KasseneckAuth, type ApiKeyAuthOptions, type RegisterUserAuthOptions, apiKeyAuth, registerUserAuth, DEFAULT_BASE_URL, DEFAULT_TIMEOUT_MS, type HttpResponseLike, type HttpRequestInit, type FetchLike, type TransportOptions, type TransportBodyFields, type KasseneckTransport, type KasseneckBinaryTransport, AUFRUFE, type Aufruf, createTransport, createBinaryTransport, KasseneckApiError, KasseneckAuthError, KasseneckHttpError, KasseneckNetworkError, KasseneckValidationError, type ValidationScope, type KasseneckError, type HttpFailureReason, type CauseDigest, isKasseneckApiError, isKasseneckAuthError, isKasseneckHttpError, isKasseneckNetworkError, isKasseneckValidationError, type ReceiptCommonOptions, type SellReceiptOptions, type SellReceiptWithPaymentsOptions, type TipOptions, type TipRecipientShare, type CancelReceiptOptions, type CancelReceiptResult, type CreateCancelReceiptOptions, type ReceiptWithCompany, sellReceipt, sellReceiptWithCompany, cancelReceipt, createCancelReceipt, zeroReceipt, getReceipt, getReceiptWithCompany, generateFullReceiptId, getFirstReceiptDate, listMyReceipts, type ListMyReceiptsOptions, type ReceiptList, type ReceiptListStats, listMyCashregisters, checkVoucherCombinationError, type SendReceiptEmailOptions, type SendReceiptEmailResult, sendReceiptEmail, downloadDailyReport, downloadMonthlyReport, type CashboxStatus, type SignatureStatus, getCashboxStatus, getSignatureStatus, type KasseneckApi, createKasseneckApi, } from './client/index.js';
 export { parseServerTimeStamp, toViennaWallClock, type ViennaWallClock } from './vienna-time.js';
 export { type KasseSettingsBetrieb, type KasseSettingsGeraet, type KasseSettings, type ArticleGroup, type KasseArtikel, KASSE_BETRIEB_STANDARD, KASSE_GERAET_STANDARD, mergeKasseSettings, fromArticleGroupPayload, fromKasseArtikelPayload, listMyArticleGroups, listMyArticles, getKasseSettings, setMyKasseSettings, setMyRegisterDeviceSettings, verteileRabatt, cancelScopeOf, receiptsScopeOf, } from './kasse/index.js';

package/dist/esm/index.js

@@ -1,5 +1,5 @@
 export { ReceiptType, VatRate, KeckPaymentMethod, CreditCardProvider, VoucherType, VoucherAction, StripeLinkMode, } from './enums/index.js';
-export { toReceiptItemPayload, fromReceiptItemPayload, receiptItemTotalCents, receiptItemIsValid, negateReceiptItem, isTipItem, toVoucherPayload, fromVoucherPayload, voucherIsValid, toReceiptPayload, fromReceiptPayload, receiptSubSumCents, receiptSumCents, CANCELLATION_REASONS, CANCELLATION_ERROR_CODES, CANCELLATION_RESERVATION_MS, isCancellationReason, isCancellationErrorCode, RECEIPT_EMAIL_ERROR_CODES, isReceiptEmailErrorCode, remainingQuantities, fromReceiptCompanyPayload, receiptCompanyTaxInfo, fromCashregisterPayload, fromReceiptSummaryPayload, ZERO_KINDS, istZeroKind, reportMonthFromDate, previousReportMonth, nextReportMonth, reportMonthKey, reportMonthReadable, toStripeUrlSessionPayload, fromStripeUrlSessionPayload, toHobexReceiptPayload, fromHobexReceiptPayload, hobexReceiptToCardPaymentData, hobexReceiptNeedsSignature, } from './models/index.js';
+export { toReceiptItemPayload, fromReceiptItemPayload, receiptItemTotalCents, receiptItemIsValid, negateReceiptItem, isTipItem, toVoucherPayload, fromVoucherPayload, voucherIsValid, toReceiptPayload, fromReceiptPayload, receiptSubSumCents, receiptSumCents, CANCELLATION_REASONS, CANCELLATION_ERROR_CODES, CANCELLATION_RESERVATION_MS, isCancellationReason, isCancellationErrorCode, fromReceiptPaymentPayload, toReceiptPaymentPayload, PAYMENT_ERROR_CODES, isPaymentErrorCode, RECEIPT_EMAIL_ERROR_CODES, isReceiptEmailErrorCode, remainingQuantities, fromReceiptCompanyPayload, receiptCompanyTaxInfo, fromCashregisterPayload, fromReceiptSummaryPayload, ZERO_KINDS, istZeroKind, reportMonthFromDate, previousReportMonth, nextReportMonth, reportMonthKey, reportMonthReadable, toStripeUrlSessionPayload, fromStripeUrlSessionPayload, toHobexReceiptPayload, fromHobexReceiptPayload, hobexReceiptToCardPaymentData, hobexReceiptNeedsSignature, } from './models/index.js';
 export { apiKeyAuth, registerUserAuth, DEFAULT_BASE_URL, DEFAULT_TIMEOUT_MS, AUFRUFE, createTransport, createBinaryTransport, KasseneckApiError, KasseneckAuthError, KasseneckHttpError, KasseneckNetworkError, KasseneckValidationError, isKasseneckApiError, isKasseneckAuthError, isKasseneckHttpError, isKasseneckNetworkError, isKasseneckValidationError, sellReceipt, sellReceiptWithCompany, cancelReceipt, createCancelReceipt, zeroReceipt, getReceipt, getReceiptWithCompany, generateFullReceiptId, getFirstReceiptDate, listMyReceipts, listMyCashregisters, checkVoucherCombinationError, sendReceiptEmail, downloadDailyReport, downloadMonthlyReport, getCashboxStatus, getSignatureStatus, createKasseneckApi, } from './client/index.js';
 export { parseServerTimeStamp, toViennaWallClock } from './vienna-time.js';
 export { KASSE_BETRIEB_STANDARD, KASSE_GERAET_STANDARD, mergeKasseSettings, fromArticleGroupPayload, fromKasseArtikelPayload, listMyArticleGroups, listMyArticles, getKasseSettings, setMyKasseSettings, setMyRegisterDeviceSettings, verteileRabatt, cancelScopeOf, receiptsScopeOf, } from './kasse/index.js';

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

@@ -27,8 +27,18 @@ 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 Werte hier sind die von `/v1` und intern. Unter `/v3` heissen die
+ * Storno-Codes nach dem /v3-Vokabular anders (`already_cancelled`,
+ * `cancellation_payments_required`, functions/gemeinsam/api-vokabular-v3.js);
+ * 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"];
+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 type CancellationErrorCode = (typeof CANCELLATION_ERROR_CODES)[number];
 export declare function isCancellationErrorCode(value: unknown): value is CancellationErrorCode;
 /** Bezug eines Storno-Belegs auf sein Original. */

package/dist/esm/models/cancellation.js

@@ -27,6 +27,16 @@ export 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 Werte hier sind die von `/v1` und intern. Unter `/v3` heissen die
+ * Storno-Codes nach dem /v3-Vokabular anders (`already_cancelled`,
+ * `cancellation_payments_required`, functions/gemeinsam/api-vokabular-v3.js);
+ * diese Namen kommen mit der Umstellung des Pakets auf `/v3`.
+ * [isCancellationErrorCode] prueft darum exakt.
  */
 export const CANCELLATION_ERROR_CODES = [
     'beleg_nicht_gefunden', // Original fehlt oder gehoert nicht zu dieser Kasse
@@ -43,6 +53,11 @@ export const CANCELLATION_ERROR_CODES = [
     'nur_eigene_belege', // Recht "eigene", fremder Beleg
     'kasse_unvollstaendig', // api_key/token fehlen am Konto bzw. an der Kasse
     'storno_fehlgeschlagen', // der Storno-Beleg selbst wurde abgelehnt (z. B. Signatur)
+    // Mehrere Zahlungen je Beleg (Rueckzahlung je Zahlung):
+    'STORNO_PAYMENTS_REQUIRED', // Teilstorno eines Belegs mit mehreren Zahlungen ohne payments
+    '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
 ];
 export function isCancellationErrorCode(value) {
     return typeof value === 'string' && CANCELLATION_ERROR_CODES.includes(value);

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

@@ -2,6 +2,8 @@ export { type ReceiptItem, type ReceiptItemPayload, type ReceiptItemPayloadRead,
 export { type Voucher, type VoucherPayload, toVoucherPayload, fromVoucherPayload, voucherIsValid } from './voucher.js';
 export { type Receipt, type ReceiptPayload, type ReceiptPayloadRead, toReceiptPayload, fromReceiptPayload, receiptSubSumCents, receiptSumCents, } from './receipt.js';
 export { type CancellationOf, type CancellationItem, type Cancellation, type CancellationReason, type CancellationErrorCode, CANCELLATION_REASONS, CANCELLATION_ERROR_CODES, CANCELLATION_RESERVATION_MS, isCancellationReason, isCancellationErrorCode, remainingQuantities, } from './cancellation.js';
+export { type ReceiptPayment, type ReceiptPaymentPayload, type ReceiptPaymentInput, fromReceiptPaymentPayload, toReceiptPaymentPayload, } from './receipt-payment.js';
+export { type PaymentErrorCode, PAYMENT_ERROR_CODES, isPaymentErrorCode } from './payment-errors.js';
 export { type ReceiptEmailErrorCode, RECEIPT_EMAIL_ERROR_CODES, isReceiptEmailErrorCode, } from './receipt-email.js';
 export { type ReceiptCompany, type ReceiptCompanyPayload, fromReceiptCompanyPayload, receiptCompanyTaxInfo, } from './receipt-company.js';
 export { type Cashregister, type CashregisterOnboarding, type CashregisterPayload, type CashregisterOnboardingPayload, fromCashregisterPayload, } from './cashregister.js';

package/dist/esm/models/index.js

@@ -2,6 +2,8 @@ export { toReceiptItemPayload, fromReceiptItemPayload, receiptItemTotalCents, re
 export { toVoucherPayload, fromVoucherPayload, voucherIsValid } from './voucher.js';
 export { toReceiptPayload, fromReceiptPayload, receiptSubSumCents, receiptSumCents, } from './receipt.js';
 export { CANCELLATION_REASONS, CANCELLATION_ERROR_CODES, CANCELLATION_RESERVATION_MS, isCancellationReason, isCancellationErrorCode, remainingQuantities, } from './cancellation.js';
+export { fromReceiptPaymentPayload, toReceiptPaymentPayload, } from './receipt-payment.js';
+export { PAYMENT_ERROR_CODES, isPaymentErrorCode } from './payment-errors.js';
 export { RECEIPT_EMAIL_ERROR_CODES, isReceiptEmailErrorCode, } from './receipt-email.js';
 export { fromReceiptCompanyPayload, receiptCompanyTaxInfo, } from './receipt-company.js';
 export { fromCashregisterPayload, } from './cashregister.js';

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

@@ -0,0 +1,22 @@
+/**
+ * Mehrere Zahlungen je Beleg — Fehlercode-Katalog, Zwilling von
+ * `functions/gemeinsam/zahlungen-core.js` ZAHLUNGS_FEHLERCODES (gleiche
+ * Codes, gleiche Reihenfolge).
+ *
+ * `createReceipt` und `cancelReceipt` legen sie bei jedem Fehler rund um
+ * `payments` (und bei den Aufrufer-Vorbedingungen wie `PAYMENTS_CONFLICT`)
+ * 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.
+ *
+ * Schreibweise: auf `/v1`, `/v2` und intern kommen die Codes gross
+ * (`PAYMENTS_SUM_MISMATCH`), unter `/v3` schreibt der Rand des Backends sie
+ * klein (`payments_sum_mismatch`, functions/gemeinsam/api-vokabular-v3.js:
+ * jeder dieser Codes 1:1 in Kleinschreibung, anders als die Storno-Codes).
+ * [isPaymentErrorCode] erkennt beide; wer selbst vergleicht, vergleicht
+ * `code.toUpperCase()`.
+ */
+export declare const PAYMENT_ERROR_CODES: readonly ["PAYMENTS_INVALID", "PAYMENT_METHOD_INVALID", "PAYMENT_AMOUNT_INVALID", "PAYMENT_TENDERED_INVALID", "PAYMENT_PROVIDER_INVALID", "PAYMENT_PROVIDER_NOT_ALLOWED", "PAYMENTS_SUM_MISMATCH", "PAYMENTS_DUE_NEGATIVE", "PAYMENTS_NOT_ALLOWED", "PAYMENTS_CONFLICT", "PAYMENTS_REQUIRED", "PAYMENT_METHOD_NOT_SUPPORTED", "TIP_PAYMENT_METHOD_INVALID", "TIP_PAYMENT_METHOD_REQUIRED", "TIP_EXCEEDS_PAYMENT", "PAYMENT_REFUND_NOT_ALLOWED", "PAYMENT_TIP_INVALID", "TIP_CONFLICT"];
+export type PaymentErrorCode = (typeof PAYMENT_ERROR_CODES)[number];
+/** Erkennt einen Code aus [PAYMENT_ERROR_CODES] — gross (`/v1`) wie klein (`/v3`). */
+export declare function isPaymentErrorCode(value: unknown): value is PaymentErrorCode | Lowercase<PaymentErrorCode>;

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

@@ -0,0 +1,42 @@
+/**
+ * Mehrere Zahlungen je Beleg — Fehlercode-Katalog, Zwilling von
+ * `functions/gemeinsam/zahlungen-core.js` ZAHLUNGS_FEHLERCODES (gleiche
+ * Codes, gleiche Reihenfolge).
+ *
+ * `createReceipt` und `cancelReceipt` legen sie bei jedem Fehler rund um
+ * `payments` (und bei den Aufrufer-Vorbedingungen wie `PAYMENTS_CONFLICT`)
+ * 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.
+ *
+ * Schreibweise: auf `/v1`, `/v2` und intern kommen die Codes gross
+ * (`PAYMENTS_SUM_MISMATCH`), unter `/v3` schreibt der Rand des Backends sie
+ * klein (`payments_sum_mismatch`, functions/gemeinsam/api-vokabular-v3.js:
+ * jeder dieser Codes 1:1 in Kleinschreibung, anders als die Storno-Codes).
+ * [isPaymentErrorCode] erkennt beide; wer selbst vergleicht, vergleicht
+ * `code.toUpperCase()`.
+ */
+export const 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_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)
+    'PAYMENTS_DUE_NEGATIVE', // Zahlbetrag < 0 (Wertgutschein groesser als der Beleg)
+    'PAYMENTS_NOT_ALLOWED', // Null-/Startbeleg mit Zahlungen, alter Storno-Weg
+    'PAYMENTS_CONFLICT', // payments zusammen mit paymentMethod oder Kartenfeldern
+    'PAYMENTS_REQUIRED', // /v3 ohne payments
+    'PAYMENT_METHOD_NOT_SUPPORTED', // paymentMethod/Kartenfelder unter /v3
+    'TIP_PAYMENT_METHOD_INVALID', // Trinkgeld-Zahlart kommt in payments nicht vor
+    'TIP_PAYMENT_METHOD_REQUIRED', // mehrere Zahlarten, tip.paymentMethod fehlt
+    'TIP_EXCEEDS_PAYMENT', // Trinkgeld uebersteigt die Zahlungen seiner Zahlart
+    'PAYMENT_REFUND_NOT_ALLOWED', // refundOf ausserhalb eines Stornos oder kein String
+    'PAYMENT_TIP_INVALID', // tipCents keine Ganzzahl, <= 0, > amountCents oder nicht am Verkauf
+    'TIP_CONFLICT', // tip und payments[].tipCents zugleich
+]);
+/** Erkennt einen Code aus [PAYMENT_ERROR_CODES] — gross (`/v1`) wie klein (`/v3`). */
+export function isPaymentErrorCode(value) {
+    return typeof value === 'string' && PAYMENT_ERROR_CODES.includes(value.toUpperCase());
+}

package/dist/esm/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/esm/models/receipt-payment.js

@@ -0,0 +1,36 @@
+import { KeckPaymentMethod, CreditCardProvider } from '../enums/index.js';
+import { readEnumKey, requireEnumKey } from './enum-payload.js';
+/** Lesepfad: nur vorhandene Felder uebernehmen, nichts ergaenzen. */
+export function fromReceiptPaymentPayload(payload) {
+    return {
+        ...(typeof payload.id === 'string' ? { id: payload.id } : {}),
+        method: readEnumKey(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: readEnumKey(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.
+ */
+export function toReceiptPaymentPayload(payment) {
+    return {
+        ...(payment.id !== undefined ? { id: payment.id } : {}),
+        method: typeof payment.method === 'object' ? payment.method.value : requireEnumKey(KeckPaymentMethod, payment.method, 'Zahlungsart').value,
+        amountCents: payment.amountCents,
+        ...(payment.tenderedCents !== undefined ? { tenderedCents: payment.tenderedCents } : {}),
+        ...(payment.changeCents !== undefined ? { changeCents: payment.changeCents } : {}),
+        ...(payment.provider !== undefined ? { provider: requireEnumKey(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/esm/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/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 { fromReceiptPaymentPayload } from './receipt-payment.js';
 /**
  * Belegzeile einer Liste — die Form, die `listMyReceipts` liefert
  * (`projectReceiptForCustomer` in functions/index.js).
@@ -48,5 +49,6 @@ export 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(fromReceiptPaymentPayload) } : {}),
     };
 }

package/dist/esm/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/esm/models/receipt.js

@@ -3,6 +3,7 @@ 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 { fromReceiptPaymentPayload, toReceiptPaymentPayload } from './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
@@ -43,6 +44,7 @@ export function toReceiptPayload(receipt) {
         signatureSuccess: receipt.signatureSuccess ?? null,
         customProjectId: receipt.customProjectId ?? null,
         ...(receipt.tipCents != null ? { tipCents: receipt.tipCents } : {}),
+        ...(receipt.payments != null ? { payments: receipt.payments.map(toReceiptPaymentPayload) } : {}),
     };
 }
 // Nullbelege haben keine Positionen -> items kann fehlen/null sein (siehe Dart-Vorbild).
@@ -78,6 +80,7 @@ export function fromReceiptPayload(payload) {
         ...(payload.cancellationReason ? { cancellationReason: payload.cancellationReason } : {}),
         ...(istZeroKind(payload.zeroKind) ? { zeroKind: payload.zeroKind } : {}),
         ...(payload.cancellations ? { cancellations: payload.cancellations.map(leseStorno) } : {}),
+        ...(Array.isArray(payload.payments) ? { payments: payload.payments.map(fromReceiptPaymentPayload) } : {}),
     };
 }
 function leseStorno(eintrag) {

package/dist/esm/receipt/layout.js

@@ -291,16 +291,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);
@@ -312,7 +309,7 @@ function kartenblock(receipt) {
             case 'myposPro':
                 return myposBlock(daten);
             case 'stripe':
-                return stripeBlock(daten, receipt.cardPaymentId ?? null);
+                return stripeBlock(daten, id);
             default:
                 return [];
         }
@@ -325,12 +322,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 —
@@ -898,7 +1000,7 @@ export 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