@kreiseck/kasseneck-api 1.11.1 → 1.13.0

package/dist/cjs/pos/texte.js

@@ -22,11 +22,12 @@
  * `placeholders` und `structure`).
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RETURN_DISPOSITION_LABELS = exports.LABELS = exports.CANCELLATION_PAYMENT_ERROR_MESSAGES = exports.RECEIPT_EMAIL_ERROR_MESSAGES = exports.CALLS_WITH_EFFECT = exports.ERROR_OUTCOME_RULES = exports.ERROR_CODE_RULES = exports.ERROR_RULES = exports.MESSAGES = void 0;
+exports.RETURN_DISPOSITION_LABELS = exports.LABELS = exports.VOUCHER_ERROR_MESSAGES = exports.CANCELLATION_PAYMENT_ERROR_MESSAGES = exports.RECEIPT_EMAIL_ERROR_MESSAGES = exports.CALLS_WITH_EFFECT = exports.ERROR_OUTCOME_RULES = exports.ERROR_CODE_RULES = exports.ERROR_RULES = exports.MESSAGES = void 0;
 exports.findErrorRule = findErrorRule;
 exports.messageOutcome = messageOutcome;
 exports.receiptEmailErrorMessage = receiptEmailErrorMessage;
 exports.cancellationPaymentErrorMessage = cancellationPaymentErrorMessage;
+exports.voucherErrorMessage = voucherErrorMessage;
 exports.labelText = labelText;
 exports.messageText = messageText;
 exports.messageAppliesTo = messageAppliesTo;
@@ -187,6 +188,39 @@ const MELDUNGEN_ROH = {
     'cancellation.tip_source_missing': { text: 'Bitte wählen: Woher kommt das Trinkgeld zurück?' },
     // Beleg mit Wertgutschein: keine Frage, das Trinkgeld geht mit (Ruling R59, asksRefundTip).
     'cancellation.tip_refunded_with_voucher': { text: 'Beleg mit Gutschein: Das Trinkgeld wird mitstorniert.' },
+    // --- Gutscheine: Fehlersätze (Zuordnung in VOUCHER_ERROR_MESSAGES) ---------
+    'voucher_error.not_found': { text: 'Diesen Gutschein gibt es in diesem Betrieb nicht.' },
+    'voucher_error.invalid': { text: 'Dieser Gutschein ist nicht gültig.' },
+    'voucher_error.invalid_code': { text: 'Der Code ist nicht vollständig oder falsch abgetippt.' },
+    'voucher_error.expired': { text: 'Der Gutschein ist abgelaufen.' },
+    'voucher_error.used_up': { text: 'Der Gutschein ist bereits aufgebraucht.' },
+    'voucher_error.blocked': { text: 'Der Gutschein ist gesperrt.' },
+    'voucher_error.cancelled': { text: 'Der Gutschein wurde storniert.' },
+    'voucher_error.insufficient_balance': { text: 'Auf dem Gutschein ist nicht genug Guthaben.' },
+    'voucher_error.exceeds_total': { text: 'Der Gutschein deckt mehr, als offen ist. Bitte den Betrag anpassen.' },
+    'voucher_error.balance_changed': { text: 'Der Gutschein wurde gerade anderswo verwendet. Bitte neu prüfen.' },
+    'voucher_error.rate_mismatch': { text: 'Dieser Gutschein gilt nur für Leistungen mit {rate} %.', placeholders: ['rate'] },
+    'voucher_error.item_mismatch': { text: 'Dieser Gutschein gilt nicht für die gewählten Positionen.' },
+    'voucher_error.already_used': { text: 'Dieser Gutschein wurde bereits verwendet.' },
+    'voucher_error.partial_cancel': { text: 'Belege mit Gutschein lassen sich nur ganz stornieren.' },
+    'voucher_error.settings_missing': { text: 'Die Gutschein-Einstellungen fehlen. Bitte die Kasse neu laden.' },
+    'voucher_error.too_many_checks': { text: 'Zu viele Versuche. Bitte in einer Stunde wieder.' },
+    'voucher_error.sale_off': { text: 'Gutscheine verkaufen geht hier noch nicht.' },
+    // Gutscheine an der Kasse, Stufe 3 (1.13.0): Sätze der Kasse selbst (nicht des Servers).
+    'voucher.reentry_needed': { text: 'Die Karte ist belastet, der Beleg fehlt noch: zu jedem Gutschein den Code erneut eingeben, dann den Beleg abschließen.' },
+    'voucher.reentry_mismatch': { text: 'Mit diesen Gutscheinen ergibt der Beleg nicht mehr den belasteten Betrag – die Karte zurückbuchen.' },
+    'voucher.not_this_voucher': { text: 'Das ist nicht der Gutschein ····-{suffix}.', placeholders: ['suffix'] },
+    'voucher.reentry_no_permission': { text: 'Die Karte ist belastet, der Beleg fehlt noch: den Gutschein-Code kann nur jemand mit dem Recht zum Einlösen nachtragen – sonst die Karte zurückbuchen.' },
+    'voucher.already_covered': { text: 'Diese Positionen deckt schon ein anderer Gutschein.' },
+    'voucher.payout_reason_too_long': { text: 'Der Grund hat höchstens 200 Zeichen.' },
+    'voucher.payout_reason_missing': { text: 'Für die Auszahlung fehlt der Grund.' },
+    'voucher.payout_check_first': { text: 'Die letzte Auszahlung ging unklar aus und kann schon gebucht sein. Erst unter „Belege“ die Liste neu laden und nachsehen, dann ist eine neue möglich.' },
+    'voucher.sale_max_amount': { text: 'Höchstens {amount} je Gutschein.', placeholders: ['amount'] },
+    'voucher.sale_not_at_terminal': { text: 'Gutscheine mit Karte am Terminal zu verkaufen geht an dieser Kasse noch nicht – bar kassieren.' },
+    'voucher.no_redeem_with_sale': { text: 'Auf einem Beleg, der Gutscheine verkauft, lässt sich kein Gutschein einlösen.' },
+    'voucher.code_not_on_receipt': { text: 'Der Code steht nicht auf dem Bon – jetzt auf den Gutschein schreiben.' },
+    'cancellation.voucher_sale_cancelled': { text: 'Der Gutschein ····-{suffix} wird mitstorniert und gilt danach nicht mehr.', placeholders: ['suffix'] },
+    'cancellation.promo_valid_again': { text: 'Der Aktionsgutschein ····-{suffix} gilt danach wieder.', placeholders: ['suffix'] },
     // --- Getrennt zahlen -----------------------------------------------------
     // Ein Tisch zahlt in Teilen, ein Beleg fuer alles. Das Teure ist eine schon
     // belastete Karte: jeder Satz, der sie betrifft, nennt den Betrag, und keiner
@@ -554,6 +588,34 @@ function cancellationPaymentErrorMessage(code) {
     const fehler = exports.CANCELLATION_PAYMENT_ERROR_MESSAGES;
     return (code !== undefined && code !== null && fehler[code]) || 'cancellation.failed';
 }
+/**
+ * Gutschein-Fehler (`/v3`): welcher `code` des Backends welchen Satz bekommt.
+ * Wie RECEIPT_EMAIL_ERROR_MESSAGES: beide Kassen entscheiden am Code. Ein
+ * unbekannter Code geht den allgemeinen Weg des Aufrufs.
+ */
+exports.VOUCHER_ERROR_MESSAGES = {
+    voucher_not_found: 'voucher_error.not_found',
+    voucher_invalid: 'voucher_error.invalid',
+    voucher_invalid_code: 'voucher_error.invalid_code',
+    voucher_expired: 'voucher_error.expired',
+    voucher_used_up: 'voucher_error.used_up',
+    voucher_blocked: 'voucher_error.blocked',
+    voucher_cancelled: 'voucher_error.cancelled',
+    voucher_insufficient_balance: 'voucher_error.insufficient_balance',
+    voucher_exceeds_total: 'voucher_error.exceeds_total',
+    voucher_balance_changed: 'voucher_error.balance_changed',
+    voucher_rate_mismatch: 'voucher_error.rate_mismatch',
+    voucher_item_mismatch: 'voucher_error.item_mismatch',
+    voucher_already_used: 'voucher_error.already_used',
+    voucher_partial_cancel: 'voucher_error.partial_cancel',
+    voucher_settings_missing: 'voucher_error.settings_missing',
+    too_many_voucher_checks: 'voucher_error.too_many_checks',
+};
+/** Der Satz zu einem Gutschein-`code`; `undefined` für jeden anderen Code. */
+function voucherErrorMessage(code) {
+    const fehler = exports.VOUCHER_ERROR_MESSAGES;
+    return code !== undefined && code !== null ? fehler[code] : undefined;
+}
 /**
  * Beschriftungen: Knoepfe, Ueberschriften, Zeilennamen – was kein Satz ist.
  *
@@ -831,6 +893,39 @@ const BESCHRIFTUNGEN_ROH = {
     'shift.collected_outside_drawer': { text: 'Kassiert, aber nicht in der Kassenlade' },
     'shift.non_cash_short': { text: 'unbar' },
     'shift.voucher_redeemed': { text: 'Gutschein eingelöst' },
+    // Gutscheine an der Kasse (1.12.0)
+    'voucher.button': { text: 'Gutschein' },
+    'voucher.redeem': { text: 'Gutschein einlösen' },
+    'voucher.sell': { text: 'Gutschein verkaufen' },
+    'voucher.payout': { text: 'Gutschein auszahlen' },
+    'voucher.code': { text: 'Code' },
+    'voucher.scan': { text: 'Code scannen' },
+    'voucher.check': { text: 'Prüfen' },
+    'voucher.amount': { text: 'Betrag' },
+    'voucher.balance': { text: 'Rest am Gutschein: {amount}', placeholders: ['amount'] },
+    'voucher.remaining_quantity': { text: '{n} von {total} übrig', placeholders: ['n', 'total'] },
+    'voucher.reason': { text: 'Grund' },
+    'voucher.multi_purpose': { text: 'Mehrzweckgutschein' },
+    'voucher.single_purpose': { text: 'Einzweckgutschein {rate} %', placeholders: ['rate'] },
+    'voucher.service': { text: 'Leistungsgutschein' },
+    'voucher.promotion': { text: 'Aktionsgutschein' },
+    'voucher.payment_line': { text: 'Gutschein ····-{suffix}', placeholders: ['suffix'] },
+    'voucher.covers_items': { text: 'Deckt: {items}', placeholders: ['items'] },
+    'voucher.code_shown_once': { text: 'Code nur jetzt sichtbar: {code}', placeholders: ['code'] },
+    'voucher.not_in_split': { text: 'Gutscheine gehen beim getrennten Kassieren nicht.' },
+    'voucher.payout_not_possible': { text: 'Dieser Gutschein lässt sich nicht auszahlen.' },
+    'voucher.add_article': { text: '{article} hinzufügen', placeholders: ['article'] },
+    'voucher.payout_confirm': { text: '{amount} bar auszahlen?', placeholders: ['amount'] },
+    'cancellation.voucher_back': { text: '{amount} geht zurück auf den Gutschein', placeholders: ['amount'] },
+    // Gutscheine an der Kasse, Stufe 3 (1.13.0)
+    'voucher.apply': { text: 'Übernehmen' },
+    'voucher.redeemable_until': { text: 'einlösbar bis {date}', placeholders: ['date'] },
+    'voucher.remove_line': { text: '{line} entfernen', placeholders: ['line'] },
+    'voucher.reenter_code': { text: 'Code erneut eingeben' },
+    'voucher.refundable_until': { text: 'rückzahlbar bis {date}', placeholders: ['date'] },
+    'voucher.code_done': { text: 'Fertig' },
+    'voucher.article': { text: 'Artikel' },
+    'voucher.add': { text: 'Hinzufügen' },
     'shift.all_payments': { text: 'Alle Zahlungen dieser Schicht (bar + unbar)' },
     'shift.receipt_count_one': { text: '1 Beleg' },
     'shift.receipt_count_other': { text: '{count} Belege', placeholders: ['count'] },

package/dist/cjs/react/index.js

@@ -48,8 +48,14 @@ function HiddenQr({ data, text = 'Antippen zum Anzeigen', children }) {
 }
 function Zeile({ zeile, renderQr, qrVerdeckt, qrVerdecktText }) {
     switch (zeile.kind) {
-        case 'text':
-            return ((0, jsx_runtime_1.jsx)("div", { className: "keck-receipt-text", style: { textAlign: AUSRICHTUNG[zeile.align], fontWeight: zeile.bold ? 'bold' : 'normal' }, children: zeile.text.length > 0 ? zeile.text : ' ' }));
+        case 'text': {
+            // Haengender Einzug wie im Zeichenraster: fuehrende Leerzeichen eines
+            // linksbuendigen Textes werden zum Einzug aller Zeilen (HTML liesse sie
+            // sonst wegfallen). Ohne fuehrende Leerzeichen bleibt alles wie bisher.
+            const einzug = zeile.align === 'left' && zeile.text.trimStart() !== '' ? zeile.text.length - zeile.text.trimStart().length : 0;
+            const text = einzug > 0 ? zeile.text.trimStart() : zeile.text;
+            return ((0, jsx_runtime_1.jsx)("div", { className: "keck-receipt-text", style: { textAlign: AUSRICHTUNG[zeile.align], fontWeight: zeile.bold ? 'bold' : 'normal', ...(einzug > 0 ? { paddingLeft: `${einzug}ch` } : {}) }, children: text.length > 0 ? text : ' ' }));
+        }
         case 'columns':
             return ((0, jsx_runtime_1.jsx)("div", { className: "keck-receipt-row", style: { display: 'flex', width: '100%', ...(zeile.bold === true ? { fontWeight: 'bold' } : {}) }, children: zeile.columns.map((spalte, index) => ((0, jsx_runtime_1.jsx)("div", { className: "keck-receipt-cell", style: {
                         // Die Breite ist ein Zwoelftel-Anteil (wie beim Bondrucker);

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

@@ -1,6 +1,9 @@
 import { ReceiptType, type ReceiptTypeKey, KeckPaymentMethod } from '../enums/index.js';
 import type { ReceiptItem } from '../models/receipt-item.js';
 import type { Voucher } from '../models/voucher.js';
+import type { PosVoucherSettings, VoucherCheck } from '../pos/gutschein.js';
+import { type VoucherDueArticle, type VoucherDueInfo } from './gutschein-plan.js';
+export { VOUCHER_ZERO_RATE_BUCKET_FROM, type VoucherDueArticle, type VoucherDueInfo } from './gutschein-plan.js';
 /**
  * Zahlbetrag eines Belegs in ganzen Cent: Zwilling von `createReceipt` im
  * Backend (Nachtrag §8), also `beleg-toepfe.belegToepfe(...).zaehlerDeltaCents`
@@ -34,6 +37,19 @@ import type { Voucher } from '../models/voucher.js';
  * sobald Trinkgeld ohne `recipients` vorkommt. Ohne angemeldeten Benutzer
  * (Geraete-Schluessel) gilt `'staff'`.
  *
+ * **Gutscheine der neuen Form** (Mehrzweck, Einzweck, Leistung, Aktion,
+ * Auszahlung): der Server macht daraus Positionen und Eintraege
+ * (`gutschein-beleg.plane`, Zwilling in `gutschein-plan.ts`). Was er dafuer
+ * aus seinen Daten liest, gibt die Kasse mit: je Einloesung/Auszahlung die
+ * Pruefung aus `checkVoucher` (`voucherInfo`, ueber den Code zugeordnet), fuer
+ * einen Einzweck-Verkauf die Gutschein-Einstellung der Kasse
+ * (`voucherSettings`, Satz), fuer einen Leistungsgutschein-Verkauf den Artikel
+ * (`voucherArticles`, Preis und Satz) und `smallBusiness` fuer ein
+ * Kleinunternehmer-Konto. Was fehlt oder was der Server abwiese, wirft
+ * `invalid_voucher` mit dem erwarteten Server-Code in `voucherErrorCode`.
+ * Ein Beleg nur aus Auszahlungen hat einen negativen Zahlbetrag (genau eine
+ * Barzahlung ueber diesen Betrag).
+ *
  * **Nicht rechenbar:** jede unbrauchbare Eingabe wirft [ReceiptDueError]
  * (`code: 'receipt_due_unavailable'`, `reason` im Einzelnen), nie still eine
  * falsche Zahl. Dann ist nichts gesendet.
@@ -62,6 +78,42 @@ export interface ReceiptDueOptions {
     }>;
     /** Pflicht, sobald Trinkgeld ohne `recipients` vorkommt (siehe Modulkommentar). */
     tipRecipient?: ReceiptDueTipRecipient;
+    /**
+     * Je Einloesung bzw. Auszahlung der neuen Form die Pruefung aus
+     * `checkVoucher`, ueber den Code zugeordnet. Fehlt sie fuer einen Code,
+     * wirft die Rechnung `invalid_voucher` mit `voucherErrorCode:
+     * 'voucher_not_found'` (die Kasse hat den Code nicht geprueft).
+     */
+    voucherInfo?: readonly VoucherDueInfo[];
+    /**
+     * Gutschein-Einstellung der Kasse (`getKasseSettings`, Block `vouchers`):
+     * Pflicht fuer jeden Verkauf eines Mehrzweck- oder Einzweckgutscheins (der
+     * Server verkauft nur mit Einstellung). Fehlt sie oder ist keine Art
+     * gewaehlt: `voucher_settings_missing`; eine andere Art als die
+     * eingestellte: `voucher_invalid`.
+     */
+    voucherSettings?: PosVoucherSettings;
+    /**
+     * Artikel fuer den Verkauf von Dienstleistungsgutscheinen (Preis und Satz,
+     * wie im Artikelstamm). Fehlt der verkaufte Artikel hier:
+     * `voucher_item_mismatch`, wie beim Server fuer einen unbekannten Artikel.
+     */
+    voucherArticles?: readonly VoucherDueArticle[];
+    /**
+     * Das Konto ist Kleinunternehmer (Konto-Fakten): Einzweck/Leistung werden zu
+     * 0 % verkauft, eine Einzweck-Einloesung verteilt sich anteilig auf alle
+     * Saetze des Korbs. Dasselbe gilt fuer einen befreit verkauften Gutschein
+     * (`VoucherCheck.exempt`) in jedem Konto, wie der Server (`kuEingefroren || ku`).
+     */
+    smallBusiness?: boolean;
+    /**
+     * Stichtag des 0-%-Topfs fuer Mehrzweck-Verkaeufe (`YYYY-MM-DD`). Vorgabe
+     * [VOUCHER_ZERO_RATE_BUCKET_FROM], wie im Backend. Nur angeben, wenn der
+     * Server ihn nachweislich anders fuehrt (Test-Umgebung).
+     */
+    zeroRateBucketFrom?: string;
+    /** Wiener Tag des Belegs (`YYYY-MM-DD`); Vorgabe: heute in Wien. */
+    today?: string;
 }
 /** Die sechs RKSV-Toepfe in Cent, Namen wie am Beleg des Backends. */
 export interface ReceiptDueBuckets {
@@ -108,7 +160,13 @@ export declare class ReceiptDueError extends Error {
     readonly reason: ReceiptDueErrorReason;
     /** Immer `'rejected'`: es ging nichts hinaus. */
     readonly outcome: "rejected";
-    constructor(reason: ReceiptDueErrorReason, message: string);
+    /**
+     * Nur bei `invalid_voucher`: der Gutschein-Code, mit dem der Server
+     * denselben Beleg abwiese (`voucher_rate_mismatch`, `voucher_exceeds_total`,
+     * `voucher_not_found` …), fuer die Meldung an der Kasse.
+     */
+    readonly voucherErrorCode?: string;
+    constructor(reason: ReceiptDueErrorReason, message: string, voucherErrorCode?: string);
 }
 export declare function isReceiptDueError(error: unknown): error is ReceiptDueError;
 type BelegArt = ReceiptType | ReceiptTypeKey | string;
@@ -116,4 +174,27 @@ type BelegArt = ReceiptType | ReceiptTypeKey | string;
 export declare function receiptDueCents(items: readonly ReceiptItem[], vouchers: readonly Voucher[], receiptType: BelegArt, options?: ReceiptDueOptions): number;
 /** Wie [receiptDueCents], dazu Zaehler-Delta, Wertgutschein-Anteil und Toepfe. */
 export declare function receiptDueBreakdown(items: readonly ReceiptItem[], vouchers: readonly Voucher[], receiptType: BelegArt, options?: ReceiptDueOptions): ReceiptDueBreakdown;
-export {};
+/** Schon gewaehlte Gutscheine und Optionen des Belegs, vor dem Gutschein, der vorbelegt wird. */
+export interface VoucherRedeemContext {
+    vouchers?: readonly Voucher[];
+    options?: ReceiptDueOptions;
+}
+/**
+ * Hoechstbetrag zum Vorbelegen einer Einloesung an der Kasse, in Cent, nie
+ * negativ: der groesste Betrag, den der Server fuer diesen Gutschein annimmt.
+ *
+ * Obergrenze: Saldo, offener Betrag; bei Einzweck die deckbaren Positionen im
+ * Topf seines Satzes abzueglich der schon gewaehlten Einloesungen dort. Befreit
+ * verkauft bzw. als Kleinunternehmer verteilt der Server anteilig auf alle
+ * Saetze (`kuTeile`); dann begrenzt jeder Topf: sein Anteil plus die schon
+ * gewaehlten Einloesungen dort darf seine Positionen nicht uebersteigen.
+ *
+ * Unter dieser Grenze wird jeder Kandidat mit genau der Rechnung von
+ * [receiptDueCents] geprueft (Rundung halber Cent, groesster Rest), zuerst
+ * Cent fuer Cent abwaerts (64 Schritte). Findet das nichts, sucht eine
+ * Bisektion ueber [1, Grenze] und prueft danach 16 Cent aufwaerts: am Rand
+ * des groessten Rests ist die Annahme nicht monoton. Leistung (wird ueber
+ * Positionen eingeloest), Aktion (Rabatt rechnet der Server) und jeder nicht
+ * aktive Gutschein: 0.
+ */
+export declare function voucherRedeemMaxCents(items: readonly ReceiptItem[], voucher: VoucherCheck, before?: VoucherRedeemContext): number;

package/dist/cjs/receipt/due.js

@@ -1,10 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReceiptDueError = exports.RECEIPT_DUE_ERROR_REASONS = void 0;
+exports.ReceiptDueError = exports.RECEIPT_DUE_ERROR_REASONS = exports.VOUCHER_ZERO_RATE_BUCKET_FROM = void 0;
 exports.isReceiptDueError = isReceiptDueError;
 exports.receiptDueCents = receiptDueCents;
 exports.receiptDueBreakdown = receiptDueBreakdown;
+exports.voucherRedeemMaxCents = voucherRedeemMaxCents;
 const index_js_1 = require("../enums/index.js");
+const validator_1 = require("@kreiseck/validator");
+const vienna_time_js_1 = require("../vienna-time.js");
+const gutschein_plan_js_1 = require("./gutschein-plan.js");
+var gutschein_plan_js_2 = require("./gutschein-plan.js");
+Object.defineProperty(exports, "VOUCHER_ZERO_RATE_BUCKET_FROM", { enumerable: true, get: function () { return gutschein_plan_js_2.VOUCHER_ZERO_RATE_BUCKET_FROM; } });
 /**
  * Warum sich der Zahlbetrag nicht rechnen laesst. Fest wie ein Backend-Code;
  * dieselbe Liste im Dart-Zwilling und in `fixtures/receipt-due-errors.json`.
@@ -40,9 +46,17 @@ class ReceiptDueError extends Error {
     reason;
     /** Immer `'rejected'`: es ging nichts hinaus. */
     outcome = 'rejected';
-    constructor(reason, message) {
+    /**
+     * Nur bei `invalid_voucher`: der Gutschein-Code, mit dem der Server
+     * denselben Beleg abwiese (`voucher_rate_mismatch`, `voucher_exceeds_total`,
+     * `voucher_not_found` …), fuer die Meldung an der Kasse.
+     */
+    voucherErrorCode;
+    constructor(reason, message, voucherErrorCode) {
         super(`Zahlbetrag: ${message}`);
         this.reason = reason;
+        if (voucherErrorCode !== undefined)
+            this.voucherErrorCode = voucherErrorCode;
     }
 }
 exports.ReceiptDueError = ReceiptDueError;
@@ -58,35 +72,192 @@ function receiptDueCents(items, vouchers, receiptType, options = {}) {
 }
 /** Wie [receiptDueCents], dazu Zaehler-Delta, Wertgutschein-Anteil und Toepfe. */
 function receiptDueBreakdown(items, vouchers, receiptType, options = {}) {
+    return rechne(items, vouchers, receiptType, options).ergebnis;
+}
+function rechne(items, vouchers, receiptType, options) {
     const art = belegArt(receiptType);
     const trinkgelder = trinkgeldAuftraege(options);
     if (trinkgelder.length > 0 && !TRINKGELD_ERLAUBT.has(art)) {
         throw new ReceiptDueError('tip_not_allowed', `Trinkgeld gibt es nur bei standard und training, nicht bei "${art}".`);
     }
     if (!UMSATZ.has(art)) {
-        return { dueCents: 0, counterDeltaCents: 0, valueVoucherFlowCents: 0, bucketsCents: null };
+        return { ergebnis: { dueCents: 0, counterDeltaCents: 0, valueVoucherFlowCents: 0, bucketsCents: null }, kunde: [], minusJeTopf: new Map(), auszahlungCents: 0 };
     }
     const positionen = items.map(innen);
-    const gutscheine = vouchers.map(gutscheinInnen);
     // index.js createReceipt: erst `tip`, dann je Zahlart aus payments[].tipCents;
     // jede Runde haengt ihre Positionen hinten an (die Basis bleibt die Ware).
     for (const auftrag of trinkgelder)
         positionen.push(...trinkgeldPositionen(auftrag, positionen, options.tipRecipient));
+    // Danach der Gutschein-Plan (gutschein-beleg.plane): seine Positionen stehen hinter Ware und Trinkgeld.
+    const plan = (0, gutschein_plan_js_1.planeGutscheine)(positionen, vouchers, art, {
+        voucherInfo: options.voucherInfo,
+        voucherSettings: options.voucherSettings,
+        voucherArticles: options.voucherArticles,
+        smallBusiness: options.smallBusiness,
+        zeroRateBucketFrom: options.zeroRateBucketFrom,
+        today: options.today ?? wienerTag(),
+    });
+    if ('fehler' in plan)
+        throw new ReceiptDueError('invalid_voucher', plan.text, plan.fehler);
+    const kunde = positionen.slice();
+    positionen.push(...plan.zusatz);
+    // gutschein-beleg.zahlbetrag: nur Wert und Rabatt, ohne Mehrzweck-Verkaeufe im 0-%-Topf.
+    const gutscheine = plan.gutscheine.filter((g) => !(g.action === index_js_1.VoucherAction.sell && g.imNullTopf === true));
     const t = belegToepfe(positionen, gutscheine);
     const fluss = wertgutscheinFlussCents(gutscheine, art);
+    const dueCents = t.zaehlerDeltaCents + fluss;
+    // Ohne Auszahlungen darf der Zahlbetrag nicht negativ werden (Einloesung hoeher als die Summe).
+    if (plan.mitPlan && dueCents + plan.auszahlungCents < 0) {
+        throw new ReceiptDueError('invalid_voucher', 'die Gutscheine uebersteigen die Summe des Belegs.', 'voucher_exceeds_total');
+    }
     return {
-        dueCents: t.zaehlerDeltaCents + fluss,
-        counterDeltaCents: t.zaehlerDeltaCents,
-        valueVoucherFlowCents: fluss,
-        bucketsCents: {
-            amountRateStandard: euroToCent(t.amountRateStandard),
-            amountRateReduced1: euroToCent(t.amountRateReduced1),
-            amountRateReduced2: euroToCent(t.amountRateReduced2),
-            amountRateZero: euroToCent(t.amountRateZero),
-            amountRateSpecial: euroToCent(t.amountRateSpecial),
-            amountRatOthers: euroToCent(t.amountRatOthers),
+        ergebnis: {
+            dueCents,
+            counterDeltaCents: t.zaehlerDeltaCents,
+            valueVoucherFlowCents: fluss,
+            bucketsCents: {
+                amountRateStandard: euroToCent(t.amountRateStandard),
+                amountRateReduced1: euroToCent(t.amountRateReduced1),
+                amountRateReduced2: euroToCent(t.amountRateReduced2),
+                amountRateZero: euroToCent(t.amountRateZero),
+                amountRateSpecial: euroToCent(t.amountRateSpecial),
+                amountRatOthers: euroToCent(t.amountRatOthers),
+            },
         },
+        kunde,
+        minusJeTopf: plan.minusJeTopf,
+        auszahlungCents: plan.auszahlungCents,
+    };
+}
+/**
+ * Hoechstbetrag zum Vorbelegen einer Einloesung an der Kasse, in Cent, nie
+ * negativ: der groesste Betrag, den der Server fuer diesen Gutschein annimmt.
+ *
+ * Obergrenze: Saldo, offener Betrag; bei Einzweck die deckbaren Positionen im
+ * Topf seines Satzes abzueglich der schon gewaehlten Einloesungen dort. Befreit
+ * verkauft bzw. als Kleinunternehmer verteilt der Server anteilig auf alle
+ * Saetze (`kuTeile`); dann begrenzt jeder Topf: sein Anteil plus die schon
+ * gewaehlten Einloesungen dort darf seine Positionen nicht uebersteigen.
+ *
+ * Unter dieser Grenze wird jeder Kandidat mit genau der Rechnung von
+ * [receiptDueCents] geprueft (Rundung halber Cent, groesster Rest), zuerst
+ * Cent fuer Cent abwaerts (64 Schritte). Findet das nichts, sucht eine
+ * Bisektion ueber [1, Grenze] und prueft danach 16 Cent aufwaerts: am Rand
+ * des groessten Rests ist die Annahme nicht monoton. Leistung (wird ueber
+ * Positionen eingeloest), Aktion (Rabatt rechnet der Server) und jeder nicht
+ * aktive Gutschein: 0.
+ */
+function voucherRedeemMaxCents(items, voucher, before = {}) {
+    if (voucher.status !== 'active')
+        return 0;
+    if (voucher.type !== 'multi_purpose' && voucher.type !== 'single_purpose')
+        return 0;
+    const saldo = Number.isInteger(voucher.balanceCents) ? voucher.balanceCents : 0;
+    const options = before.options ?? {};
+    const vorher = before.vouchers ?? [];
+    const r = rechne(items, vorher, 'standard', options);
+    // Rundung je Topf: hoechstens ein halber Cent je Topf ueber dem offenen Betrag.
+    let oben = Math.min(saldo, r.ergebnis.dueCents + r.auszahlungCents + 6, HOECHSTBETRAG_CENTS);
+    if (voucher.type === 'single_purpose') {
+        const deckbar = r.kunde.filter(gutschein_plan_js_1.istDeckbar);
+        const topfBasis = (topf) => (0, gutschein_plan_js_1.centSumme)(deckbar.filter((it) => (0, gutschein_plan_js_1.topfFuerSatz)(it.vat) === topf));
+        if (voucher.exempt === true || options.smallBusiness === true) {
+            oben = Math.min(oben, kuGrenze(r.kunde, topfBasis, r.minusJeTopf));
+        }
+        else {
+            if (!Number.isInteger(voucher.vatRateBp))
+                return 0;
+            const topf = (0, gutschein_plan_js_1.topfFuerSatz)(voucher.vatRateBp / 100);
+            oben = Math.min(oben, topfBasis(topf) - (r.minusJeTopf.get(topf) ?? 0));
+        }
+    }
+    if (oben <= 0)
+        return 0;
+    const code = probeCode(vorher);
+    const info = [...(options.voucherInfo ?? []), { code, check: voucher }];
+    const passt = (cents) => {
+        try {
+            rechne(items, [...vorher, { action: 'redeem', type: voucher.type, code, amountCents: cents }], 'standard', { ...options, voucherInfo: info });
+            return true;
+        }
+        catch (fehler) {
+            if (fehler instanceof ReceiptDueError)
+                return false;
+            throw fehler;
+        }
     };
+    return groessterBetrag(oben, passt);
+}
+/** Schritte der linearen Suche, bevor die Bisektion uebernimmt. */
+const LINEAR_SCHRITTE = 64;
+/** Cent, die nach der Bisektion aufwaerts geprueft werden (nicht monotoner Rand). */
+const NACHPRUEFEN = 16;
+/** Groesster Betrag in [1, oben], den `passt` annimmt; 0, wenn keiner gefunden wird. */
+function groessterBetrag(oben, passt) {
+    const untenLinear = Math.max(0, oben - LINEAR_SCHRITTE);
+    for (let cents = oben; cents > untenLinear; cents--) {
+        if (passt(cents))
+            return cents;
+    }
+    // Bisektion ueber [1, untenLinear]: `ja` angenommen (0 gilt als angenommen), `nein` abgewiesen.
+    let ja = 0;
+    let nein = untenLinear + 1;
+    while (nein - ja > 1) {
+        const mitte = ja + Math.floor((nein - ja) / 2);
+        if (passt(mitte))
+            ja = mitte;
+        else
+            nein = mitte;
+    }
+    let bester = ja;
+    for (let cents = ja + 1; cents <= Math.min(untenLinear, ja + NACHPRUEFEN); cents++) {
+        if (passt(cents))
+            bester = cents;
+    }
+    return bester;
+}
+/**
+ * Obergrenze fuer eine anteilige Einloesung (`kuTeile`): je Satz ist der Anteil
+ * mindestens `floor(c * basis / summe)`, je Topf also mehr als
+ * `c * basisTopf / summe - saetzeImTopf`. Mit dem freien Rest des Topfs
+ * (Positionen minus schon gewaehlte Einloesungen) folgt
+ * `c <= (frei + saetzeImTopf) * summe / basisTopf`.
+ */
+function kuGrenze(kunde, topfBasis, minusJeTopf) {
+    const saetze = (0, gutschein_plan_js_1.kuSaetze)(kunde);
+    const summe = saetze.reduce((a, x) => a + x.basis, 0);
+    let grenze = summe;
+    const jeTopf = new Map();
+    for (const x of saetze) {
+        const topf = (0, gutschein_plan_js_1.topfFuerSatz)(x.satzBp / 100);
+        const t = jeTopf.get(topf) ?? { basis: 0, anzahl: 0 };
+        t.basis += x.basis;
+        t.anzahl += 1;
+        jeTopf.set(topf, t);
+    }
+    for (const [topf, t] of jeTopf) {
+        const frei = topfBasis(topf) - (minusJeTopf.get(topf) ?? 0);
+        grenze = Math.min(grenze, Math.floor(((frei + t.anzahl) * summe) / t.basis));
+    }
+    return Math.max(0, grenze);
+}
+const HOECHSTBETRAG_CENTS = 1_000_000;
+/** Ein gueltiger Code, der unter den schon gewaehlten Gutscheinen nicht vorkommt (nur fuer die Probe-Rechnung). */
+function probeCode(vorher) {
+    const belegt = new Set(vorher.map((v) => {
+        const g = typeof v.code === 'string' ? validator_1.VoucherCode.validate(v.code) : null;
+        return g && g.ok ? g.normalized : null;
+    }));
+    for (let i = 0;; i++) {
+        const code = validator_1.VoucherCode.generate(Uint8Array.from({ length: 11 }, (_, k) => (i + k * 7) & 31));
+        if (!belegt.has(code))
+            return code;
+    }
+}
+/** Heute in Wien als `YYYY-MM-DD`. */
+function wienerTag() {
+    const w = (0, vienna_time_js_1.toViennaWallClock)(new Date());
+    return `${w.year}-${String(w.month).padStart(2, '0')}-${String(w.day).padStart(2, '0')}`;
 }
 function belegArt(wert) {
     const text = typeof wert === 'object' && wert !== null ? wert.value : wert;
@@ -109,12 +280,15 @@ function innen(item, i) {
     if (typeof item.quantity !== 'number' || !Number.isFinite(item.quantity))
         throw new ReceiptDueError('invalid_item', `Position ${i + 1} hat keine gueltige Menge.`);
     const tip = item.kind === 'tip' ? (item.recipient?.owner === true ? 'owner' : 'staff') : null;
-    return { amount: item.quantity, priceOne: Math.round(item.priceCents) / 100, vat: satz, tip };
-}
-function gutscheinInnen(v, i) {
-    if (!Number.isSafeInteger(v.valueCents))
-        throw new ReceiptDueError('invalid_voucher', `Gutschein ${i + 1} hat keinen ganzen Cent-Wert.`);
-    return { action: String(v.action), type: String(v.type), value: Math.round(v.valueCents) / 100 };
+    return {
+        amount: item.quantity,
+        priceOne: Math.round(item.priceCents) / 100,
+        vat: satz,
+        tip,
+        // `kind: null` ist wie keines (der Server prueft `!it.kind`).
+        ...(item.kind != null ? { kind: item.kind } : {}),
+        ...(item.articleId != null ? { articleId: item.articleId } : {}),
+    };
 }
 /** Trinkgeld-Auftraege in der Reihenfolge des Servers: `tip`, dann je Zahlart die Summe der `tipCents`. */
 function trinkgeldAuftraege(options) {
@@ -234,18 +408,6 @@ function splitOwnerTip(cents, jeSatz) {
     return verteilt.map(({ vat, cents: c }) => ({ vat, cents: c }));
 }
 const FUENF = ['amountRateStandard', 'amountRateReduced1', 'amountRateReduced2', 'amountRateZero', 'amountRateSpecial'];
-/** `vat-buckets.bucketFuerSatz`. */
-function topfFuerSatz(vat) {
-    switch (vat) {
-        case 20: return 'amountRateStandard';
-        case 10: return 'amountRateReduced1';
-        case 13: return 'amountRateReduced2';
-        case 0: return 'amountRateZero';
-        case 19: return 'amountRateSpecial';
-        case 4.9: return 'amountRateSpecial';
-        default: return 'amountRatOthers';
-    }
-}
 /** `beleg-toepfe.belegToepfe`, Schritt fuer Schritt. */
 function belegToepfe(positionen, gutscheine) {
     const t = { amountRateStandard: 0, amountRateReduced1: 0, amountRateReduced2: 0, amountRateZero: 0, amountRateSpecial: 0, amountRatOthers: 0 };
@@ -254,7 +416,7 @@ function belegToepfe(positionen, gutscheine) {
         if (p.tip === 'staff')
             personal += p.amount * p.priceOne;
         else
-            t[topfFuerSatz(p.vat)] += p.priceOne * p.amount;
+            t[(0, gutschein_plan_js_1.topfFuerSatz)(p.vat)] += p.priceOne * p.amount;
     }
     const gesamt = t.amountRateStandard + t.amountRateReduced1 + t.amountRateReduced2 + t.amountRateZero + t.amountRateSpecial;
     if (gutscheine.length > 0) {
@@ -290,17 +452,21 @@ function belegToepfe(positionen, gutscheine) {
         euroToCent(t.amountRateZero) + euroToCent(t.amountRateSpecial) + euroToCent(t.amountRatOthers);
     return { ...t, zaehlerDeltaCents };
 }
-/** `zahlungen-core.wertgutscheinFlussCents`. */
+/**
+ * `zahlungen-core.wertgutscheinFlussCents`: Eintraege im 0-%-Topf
+ * (`imNullTopf`) stehen schon als Position; eine Auszahlung ohne
+ * Topf-Position mindert den Zahlbetrag.
+ */
 function wertgutscheinFlussCents(gutscheine, art) {
     const vz = art === 'cancellation' ? -1 : 1;
     let cents = 0;
     for (const v of gutscheine) {
-        if (v.type !== index_js_1.VoucherType.value || !Number.isFinite(v.value))
+        if (v.type !== index_js_1.VoucherType.value || v.imNullTopf === true || !Number.isFinite(v.value))
             continue;
         const c = euroToCent(v.value);
         if (v.action === index_js_1.VoucherAction.sell)
             cents += c;
-        else if (v.action === index_js_1.VoucherAction.redeem)
+        else if (v.action === index_js_1.VoucherAction.redeem || v.action === index_js_1.VoucherAction.payout)
             cents -= c;
     }
     return vz * cents + 0;

package/dist/cjs/receipt/grid.js

@@ -63,10 +63,22 @@ function renderReceiptGrid(layout, options = {}) {
     const lines = [];
     for (const z of layout.lines) {
         switch (z.kind) {
-            case 'text':
+            case 'text': {
+                // Haengender Einzug: ein linksbuendiger Text mit fuehrenden Leerzeichen
+                // (Vermerke unter einer Gutscheinzeile, „  Grund: …“) bricht mit
+                // demselben Einzug um, auf 32 wie auf 48 Zeichen. Passt er in eine
+                // Zeile, ergibt das dieselben Zeichen wie ohne Einzugsregel.
+                const einzug = z.align === 'left' ? z.text.length - z.text.trimStart().length : 0;
+                if (einzug > 0 && einzug < zeichen && z.text.trimStart() !== '') {
+                    const vorn = ' '.repeat(einzug);
+                    for (const t of (0, escpos_js_1.wrapText)(z.text.slice(einzug), zeichen - einzug))
+                        lines.push({ text: ausrichten(vorn + t, zeichen, 'left'), kind: 'text', bold: z.bold });
+                    break;
+                }
                 for (const t of (0, escpos_js_1.wrapText)(z.text, zeichen))
                     lines.push({ text: ausrichten(t, zeichen, z.align), kind: 'text', bold: z.bold });
                 break;
+            }
             case 'banner': {
                 // Der Rahmen ist Teil des Rasters: eine Zeile '=' ueber die volle Breite
                 // davor und danach. So setzt ihn jeder Weg -- Bildschirm, Bon, ePOS, PDF,