@kreiseck/kasseneck-api 0.31.0 → 1.0.0-rc.2

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

@@ -1,5 +1,5 @@
 import type { PosPaperSize } from '../printing/escpos.js';
-import { type QrModulGroesse } from '../printing/index.js';
+import { type QrModuleSize } from '../printing/index.js';
 import type { ReceiptLayout } from './layout.js';
 /**
  * Das Beleg-Blatt: die vollstaendige Folge dessen, was auf dem Papier steht --
@@ -15,85 +15,85 @@ import type { ReceiptLayout } from './layout.js';
  * Punkte breit, eine Zeile 24 Punkte hoch. Am Bildschirm ist eine Zeile `2ch`,
  * im PDF zwei Zeichenbreiten.
  */
-export type LogoStufe = 'S' | 'M' | 'L' | 'XL';
+export type SheetLogoSize = 'S' | 'M' | 'L' | 'XL';
 /** Kasten je Stufe: Anteil der Blattbreite und Hoehe in Zeilen (Werte der Web-Kasse). */
-export declare const LOGO_STUFEN: Readonly<Record<LogoStufe, {
-    readonly breiteAnteil: number;
-    readonly hoeheZeilen: number;
+export declare const SHEET_LOGO_SIZES: Readonly<Record<SheetLogoSize, {
+    readonly widthFraction: number;
+    readonly heightLines: number;
 }>>;
-export declare const PUNKTE_JE_ZEICHEN = 12;
-export declare const PUNKTE_JE_ZEILE = 24;
-export interface BlattLogo {
-    stufe: LogoStufe;
+export declare const DOTS_PER_CHAR = 12;
+export declare const DOTS_PER_LINE = 24;
+export interface SheetLogo {
+    size: SheetLogoSize;
     /** Pixelmass des Originalbilds -- ohne das laesst sich nicht einpassen. */
-    pxBreite: number;
-    pxHoehe: number;
+    pixelWidth: number;
+    pixelHeight: number;
 }
-export interface LogoMass {
+export interface LogoDimensions {
     /** Anteil der Blattbreite (0..1). */
-    breiteAnteil: number;
+    widthFraction: number;
     /** Hoehe in Zeilen (nicht ganzzahlig). */
-    hoeheZeilen: number;
+    heightLines: number;
 }
-export type BlattBlock = {
-    readonly art: 'zeile';
+export type SheetBlock = {
+    readonly kind: 'line';
     readonly text: string;
-    readonly fett: boolean;
-    readonly leer: boolean;
+    readonly bold: boolean;
+    readonly blank: boolean;
 } | {
-    readonly art: 'logo';
-    readonly breiteAnteil: number;
-    readonly hoeheZeilen: number;
+    readonly kind: 'logo';
+    readonly widthFraction: number;
+    readonly heightLines: number;
 } | {
-    readonly art: 'qr';
-    readonly nutzlast: string;
-    readonly breiteAnteil: number;
+    readonly kind: 'qr';
+    readonly payload: string;
+    readonly widthFraction: number;
 } | {
-    readonly art: 'marke';
-    readonly breite: number;
-    readonly hoehe: number;
+    readonly kind: 'brandMark';
+    readonly width: number;
+    readonly height: number;
 };
-export interface BelegBlatt {
-    readonly zeichen: number;
-    readonly bloecke: readonly BlattBlock[];
+export interface ReceiptSheet {
+    readonly charsPerLine: number;
+    readonly blocks: readonly SheetBlock[];
 }
-export interface BelegBlattOptionen {
+export interface ReceiptSheetOptions {
     /** Zeichen je Zeile; Vorgabe nach `layout.paperSize` (32/48). */
-    zeichen?: number;
+    charsPerLine?: number;
     /** Firmenlogo; ohne Angabe kein Logo-Block. */
-    logo?: BlattLogo | null;
+    logo?: SheetLogo | null;
     /** Das Kasseneck-Logo am Ende (Konto-Flag `kreiseck_logo`). */
-    marke?: boolean;
+    brandMark?: boolean;
     /** Geraete-Einstellung fuer die QR-Modulgroesse; Vorgabe `auto` (hoechstens 6 Punkte je Modul) — wie die Druckwege. */
-    qrGroesse?: QrModulGroesse;
+    qrModuleSize?: QrModuleSize;
 }
 /**
  * 32 Zeichen sind 58 mm, 48 sind 80 mm; andere Breiten behalten das Papier des
- * Layouts. Der QR-Anteil (`qrBlattAnteil`) wird dann fuer die Kopfbreite
+ * Layouts. Der QR-Anteil (`qrSheetWidthFraction`) wird dann fuer die Kopfbreite
  * DIESES Papiers gerechnet, nicht fuer die gewaehlte Zeichenzahl.
  */
-export declare function papierFuerZeichen(zeichen: number, vorgabe: PosPaperSize): PosPaperSize;
+export declare function paperSizeForChars(chars: number, fallback: PosPaperSize): PosPaperSize;
 /**
  * Obergrenze der Logo-Pixel, die der Bildschirm noch anzeigen darf -- exakt
- * dieselbe Grenze wie im Druck-Kit (`LOGO_PIXEL_MAX` in `druck-logo.ts`):
+ * dieselbe Grenze wie im Druck-Kit (`LOGO_MAX_PIXELS` in `druck-logo.ts`):
  * Bon und ePOS lehnen ein Logo ueber 4096x4096px schon beim Rastern ab (ein
  * grosses Bild blockiert das Geraet). Ohne diese Grenze wuerde der
  * Bildschirm ein Logo zeigen, das der Bon nie druckt -- Bildschirm und
  * Papier waeren sich uneins, genau das soll das Beleg-Blatt verhindern.
  */
-export declare const LOGO_PIXEL_MAX = 4096;
+export declare const LOGO_MAX_PIXELS = 4096;
 /** Reine Pruefung, ob ein Logo dieser Pixelmasse noch angezeigt/gedruckt werden darf. */
-export declare function logoPixelZulaessig(breite: number, hoehe: number): boolean;
+export declare function isLogoPixelSizeAllowed(width: number, height: number): boolean;
 /**
  * Das Logo in den Kasten seiner Stufe einpassen -- **nie hochrechnen**: ein
  * Bildpixel wird hoechstens ein Druckpunkt. Ein kleines Logo bleibt klein,
  * statt am Bon verwaschen zu werden (so hielten es PDF und Web-Kasse schon).
  */
-export declare function logoMass(logo: BlattLogo, zeichen: number): LogoMass;
+export declare function logoDimensions(logo: SheetLogo, chars: number): LogoDimensions;
 /** Das Mass in ganzen Druckpunkten -- so gross muss das Rasterbild fuer den Bon sein. */
-export declare function logoRasterMass(mass: LogoMass, zeichen: number): {
-    breite: number;
-    hoehe: number;
+export declare function logoRasterSize(dimensions: LogoDimensions, chars: number): {
+    width: number;
+    height: number;
 };
 /**
  * Anteil der Blattbreite, den der QR am Drucker einnimmt -- dieselbe Rechnung
@@ -105,5 +105,5 @@ export declare function logoRasterMass(mass: LogoMass, zeichen: number): {
  * darum mit Fehlerkorrektur M und einer Ruhezone von 4 Modulen zeichnen, die
  * den Kasten ganz ausfuellt -- sonst stimmt die Modulgroesse nicht mit dem Bon.
  */
-export declare function qrBlattAnteil(nutzlast: string, papier: PosPaperSize, groesse?: QrModulGroesse): number;
-export declare function belegBlatt(layout: ReceiptLayout, optionen?: BelegBlattOptionen): BelegBlatt;
+export declare function qrSheetWidthFraction(payload: string, paperSize: PosPaperSize, size?: QrModuleSize): number;
+export declare function receiptSheet(layout: ReceiptLayout, options?: ReceiptSheetOptions): ReceiptSheet;

package/dist/esm/receipt/blatt.js

@@ -1,63 +1,63 @@
-import { QR_DRUCK_PUNKTE, QR_RUHEZONE_MODULE, qrGroesseFuer, qrPasstInVersion, qrRasterPunkte, } from '../printing/index.js';
-import { renderReceiptGrid, ZEICHEN_JE_PAPIER } from './grid.js';
-import { MARKE_RASTER } from './marke-daten.js';
+import { QR_PRINT_WIDTH_DOTS, QR_QUIET_ZONE_MODULES, qrSizingFor, qrFitsInVersion, qrRasterDots, } from '../printing/index.js';
+import { renderReceiptGrid, CHARS_PER_PAPER_SIZE } from './grid.js';
+import { BRAND_MARK_RASTERS } from './marke-daten.js';
 /** Kasten je Stufe: Anteil der Blattbreite und Hoehe in Zeilen (Werte der Web-Kasse). */
-export const LOGO_STUFEN = {
-    S: { breiteAnteil: 0.42, hoeheZeilen: 5 },
-    M: { breiteAnteil: 0.62, hoeheZeilen: 8 },
-    L: { breiteAnteil: 0.8, hoeheZeilen: 12 },
-    XL: { breiteAnteil: 0.94, hoeheZeilen: 16 },
+export const SHEET_LOGO_SIZES = {
+    S: { widthFraction: 0.42, heightLines: 5 },
+    M: { widthFraction: 0.62, heightLines: 8 },
+    L: { widthFraction: 0.8, heightLines: 12 },
+    XL: { widthFraction: 0.94, heightLines: 16 },
 };
-export const PUNKTE_JE_ZEICHEN = 12;
-export const PUNKTE_JE_ZEILE = 24;
+export const DOTS_PER_CHAR = 12;
+export const DOTS_PER_LINE = 24;
 /**
  * 32 Zeichen sind 58 mm, 48 sind 80 mm; andere Breiten behalten das Papier des
- * Layouts. Der QR-Anteil (`qrBlattAnteil`) wird dann fuer die Kopfbreite
+ * Layouts. Der QR-Anteil (`qrSheetWidthFraction`) wird dann fuer die Kopfbreite
  * DIESES Papiers gerechnet, nicht fuer die gewaehlte Zeichenzahl.
  */
-export function papierFuerZeichen(zeichen, vorgabe) {
-    if (zeichen === ZEICHEN_JE_PAPIER.mm58)
+export function paperSizeForChars(chars, fallback) {
+    if (chars === CHARS_PER_PAPER_SIZE.mm58)
         return 'mm58';
-    if (zeichen === ZEICHEN_JE_PAPIER.mm80)
+    if (chars === CHARS_PER_PAPER_SIZE.mm80)
         return 'mm80';
-    return vorgabe;
+    return fallback;
 }
 /**
  * Obergrenze der Logo-Pixel, die der Bildschirm noch anzeigen darf -- exakt
- * dieselbe Grenze wie im Druck-Kit (`LOGO_PIXEL_MAX` in `druck-logo.ts`):
+ * dieselbe Grenze wie im Druck-Kit (`LOGO_MAX_PIXELS` in `druck-logo.ts`):
  * Bon und ePOS lehnen ein Logo ueber 4096x4096px schon beim Rastern ab (ein
  * grosses Bild blockiert das Geraet). Ohne diese Grenze wuerde der
  * Bildschirm ein Logo zeigen, das der Bon nie druckt -- Bildschirm und
  * Papier waeren sich uneins, genau das soll das Beleg-Blatt verhindern.
  */
-export const LOGO_PIXEL_MAX = 4096;
+export const LOGO_MAX_PIXELS = 4096;
 /** Reine Pruefung, ob ein Logo dieser Pixelmasse noch angezeigt/gedruckt werden darf. */
-export function logoPixelZulaessig(breite, hoehe) {
-    return breite > 0 && hoehe > 0 && breite <= LOGO_PIXEL_MAX && hoehe <= LOGO_PIXEL_MAX;
+export function isLogoPixelSizeAllowed(width, height) {
+    return width > 0 && height > 0 && width <= LOGO_MAX_PIXELS && height <= LOGO_MAX_PIXELS;
 }
 /**
  * Das Logo in den Kasten seiner Stufe einpassen -- **nie hochrechnen**: ein
  * Bildpixel wird hoechstens ein Druckpunkt. Ein kleines Logo bleibt klein,
  * statt am Bon verwaschen zu werden (so hielten es PDF und Web-Kasse schon).
  */
-export function logoMass(logo, zeichen) {
-    if (!(logo.pxBreite > 0) || !(logo.pxHoehe > 0))
+export function logoDimensions(logo, chars) {
+    if (!(logo.pixelWidth > 0) || !(logo.pixelHeight > 0))
         throw new Error('Logo ohne Pixelmass');
-    const stufe = LOGO_STUFEN[logo.stufe];
+    const stufe = SHEET_LOGO_SIZES[logo.size];
     if (stufe === undefined)
-        throw new Error(`Unbekannte Logo-Stufe: ${String(logo.stufe)}`);
-    const blattPunkte = zeichen * PUNKTE_JE_ZEICHEN;
-    const faktor = Math.min((stufe.breiteAnteil * blattPunkte) / logo.pxBreite, (stufe.hoeheZeilen * PUNKTE_JE_ZEILE) / logo.pxHoehe, 1);
+        throw new Error(`Unbekannte Logo-Stufe: ${String(logo.size)}`);
+    const blattPunkte = chars * DOTS_PER_CHAR;
+    const faktor = Math.min((stufe.widthFraction * blattPunkte) / logo.pixelWidth, (stufe.heightLines * DOTS_PER_LINE) / logo.pixelHeight, 1);
     return {
-        breiteAnteil: (logo.pxBreite * faktor) / blattPunkte,
-        hoeheZeilen: (logo.pxHoehe * faktor) / PUNKTE_JE_ZEILE,
+        widthFraction: (logo.pixelWidth * faktor) / blattPunkte,
+        heightLines: (logo.pixelHeight * faktor) / DOTS_PER_LINE,
     };
 }
 /** Das Mass in ganzen Druckpunkten -- so gross muss das Rasterbild fuer den Bon sein. */
-export function logoRasterMass(mass, zeichen) {
+export function logoRasterSize(dimensions, chars) {
     return {
-        breite: Math.max(1, Math.round(mass.breiteAnteil * zeichen * PUNKTE_JE_ZEICHEN)),
-        hoehe: Math.max(1, Math.round(mass.hoeheZeilen * PUNKTE_JE_ZEILE)),
+        width: Math.max(1, Math.round(dimensions.widthFraction * chars * DOTS_PER_CHAR)),
+        height: Math.max(1, Math.round(dimensions.heightLines * DOTS_PER_LINE)),
     };
 }
 /**
@@ -70,35 +70,35 @@ export function logoRasterMass(mass, zeichen) {
  * darum mit Fehlerkorrektur M und einer Ruhezone von 4 Modulen zeichnen, die
  * den Kasten ganz ausfuellt -- sonst stimmt die Modulgroesse nicht mit dem Bon.
  */
-export function qrBlattAnteil(nutzlast, papier, groesse = 'auto') {
-    if (nutzlast === '')
+export function qrSheetWidthFraction(payload, paperSize, size = 'auto') {
+    if (payload === '')
         return 0;
     // Ein Inhalt, der in keine QR-Version passt (Fehlerkorrektur M, hoechstens
-    // 2331 Byte), wuerde hier `qrGroesseFuer` -> `qrModulAnzahl` zum Werfen
+    // 2331 Byte), wuerde hier `qrSizingFor` -> `qrModuleCount` zum Werfen
     // bringen -- und riss damit jeden Zeichner mit, der das Blatt baut
     // (Bildschirm, Bon, PDF). 0, wie bei leerer Nutzlast: der Beleg steht ohne
-    // QR, statt gar nicht zu stehen. `qrModulAnzahl` selbst wirft weiter -- wer
+    // QR, statt gar nicht zu stehen. `qrModuleCount` selbst wirft weiter -- wer
     // es ausserhalb des Blatts aufruft, soll den Fehler sehen.
-    if (!qrPasstInVersion(nutzlast))
+    if (!qrFitsInVersion(payload))
         return 0;
-    const papierPunkte = QR_DRUCK_PUNKTE[papier];
-    const mass = qrGroesseFuer({ nutzlast, papierbreitePunkte: papierPunkte, groesse });
-    if (mass.passt)
-        return mass.breitePunkte / papierPunkte;
-    return ((mass.module + 2 * QR_RUHEZONE_MODULE) * qrRasterPunkte(papier, mass.module, { groesse })) / papierPunkte;
+    const papierPunkte = QR_PRINT_WIDTH_DOTS[paperSize];
+    const mass = qrSizingFor({ payload: payload, paperWidthDots: papierPunkte, moduleSize: size });
+    if (mass.fits)
+        return mass.widthDots / papierPunkte;
+    return ((mass.modules + 2 * QR_QUIET_ZONE_MODULES) * qrRasterDots(paperSize, mass.modules, { moduleSize: size })) / papierPunkte;
 }
-export function belegBlatt(layout, optionen = {}) {
-    const grid = renderReceiptGrid(layout, optionen.zeichen === undefined ? {} : { zeichen: optionen.zeichen });
-    const zeichen = grid.zeichen;
-    const papier = papierFuerZeichen(zeichen, layout.paperSize);
-    const qrGroesse = optionen.qrGroesse ?? 'auto';
-    const leerzeile = { art: 'zeile', text: ' '.repeat(zeichen), fett: false, leer: true };
+export function receiptSheet(layout, options = {}) {
+    const grid = renderReceiptGrid(layout, options.charsPerLine === undefined ? {} : { charsPerLine: options.charsPerLine });
+    const zeichen = grid.charsPerLine;
+    const papier = paperSizeForChars(zeichen, layout.paperSize);
+    const qrGroesse = options.qrModuleSize ?? 'auto';
+    const leerzeile = { kind: 'line', text: ' '.repeat(zeichen), bold: false, blank: true };
     const block = (z) => z.kind === 'qr'
-        ? { art: 'qr', nutzlast: z.qr ?? '', breiteAnteil: qrBlattAnteil(z.qr ?? '', papier, qrGroesse) }
-        : { art: 'zeile', text: z.text, fett: z.bold, leer: z.kind === 'space' };
+        ? { kind: 'qr', payload: z.qr ?? '', widthFraction: qrSheetWidthFraction(z.qr ?? '', papier, qrGroesse) }
+        : { kind: 'line', text: z.text, bold: z.bold, blank: z.kind === 'space' };
     const bloecke = [];
     let i = 0;
-    if (optionen.logo) {
+    if (options.logo) {
         // Fuehrende Aufdrucke (Testkasse, Testsignatur) bleiben ganz oben: wer den
         // Beleg sieht, sieht zuerst, dass er nicht gilt.
         while (i < grid.lines.length && grid.lines[i].kind === 'banner') {
@@ -109,21 +109,21 @@ export function belegBlatt(layout, optionen = {}) {
         // Rahmen oder an den Firmennamen kleben.
         if (i > 0)
             bloecke.push(leerzeile);
-        bloecke.push({ art: 'logo', ...logoMass(optionen.logo, zeichen) });
+        bloecke.push({ kind: 'logo', ...logoDimensions(options.logo, zeichen) });
         bloecke.push(leerzeile);
     }
     for (; i < grid.lines.length; i += 1)
         bloecke.push(block(grid.lines[i]));
-    if (optionen.marke === true) {
-        // Das Raster deckt nur die beiden bekannten Papierbreiten ab (`MARKE_RASTER`).
+    if (options.brandMark === true) {
+        // Das Raster deckt nur die beiden bekannten Papierbreiten ab (`BRAND_MARK_RASTERS`).
         // Faende sich hier eine dritte, faellt die Marke weg statt ein Raster in
         // falscher Groesse zu drucken -- derselbe Grundsatz wie beim Firmenlogo:
         // eine Marke ist Zierde, der Beleg ist Pflicht.
-        const raster = MARKE_RASTER[papier];
+        const raster = BRAND_MARK_RASTERS[papier];
         if (raster) {
             bloecke.push(leerzeile);
-            bloecke.push({ art: 'marke', breite: raster.breite, hoehe: raster.hoehe });
+            bloecke.push({ kind: 'brandMark', width: raster.width, height: raster.height });
         }
     }
-    return { zeichen, bloecke };
+    return { charsPerLine: zeichen, blocks: bloecke };
 }

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

@@ -9,4 +9,4 @@ import type { ReceiptItem } from '../models/receipt-item.js';
  * Abrunden uebrig bleiben, gehen der Reihe nach an die Gruppen mit dem
  * groessten Bruchteil; keine Zeile ist je groesser als der Umsatz ihres Satzes.
  */
-export declare function verteileRabatt(positionen: ReceiptItem[], rabattCents: number, name?: string): ReceiptItem[];
+export declare function distributeDiscount(items: ReceiptItem[], discountCents: number, name?: string): ReceiptItem[];

package/dist/esm/receipt/discount.js

@@ -9,15 +9,15 @@ import { receiptItemTotalCents } from '../models/receipt-item.js';
  * Abrunden uebrig bleiben, gehen der Reihe nach an die Gruppen mit dem
  * groessten Bruchteil; keine Zeile ist je groesser als der Umsatz ihres Satzes.
  */
-export function verteileRabatt(positionen, rabattCents, name = 'Rabatt') {
-    if (!Number.isInteger(rabattCents) || rabattCents < 0) {
+export function distributeDiscount(items, discountCents, name = 'Rabatt') {
+    if (!Number.isInteger(discountCents) || discountCents < 0) {
         throw new Error('Rabatt muss eine ganze Zahl in Cent >= 0 sein');
     }
-    if (rabattCents === 0)
+    if (discountCents === 0)
         return [];
     // Umsatz je Steuersatz (nur positive Positionen -- Rabatte/Stornos zaehlen nicht mit)
     const gruppen = new Map();
-    for (const p of positionen) {
+    for (const p of items) {
         const betrag = receiptItemTotalCents(p);
         if (betrag <= 0)
             continue;
@@ -27,12 +27,12 @@ export function verteileRabatt(positionen, rabattCents, name = 'Rabatt') {
         gruppen.set(key, g);
     }
     const gesamt = [...gruppen.values()].reduce((s, g) => s + g.umsatz, 0);
-    if (rabattCents > gesamt)
+    if (discountCents > gesamt)
         throw new Error('Rabatt uebersteigt den Umsatz');
     const liste = [...gruppen.values()];
-    const exakt = liste.map((g) => (rabattCents * g.umsatz) / gesamt);
+    const exakt = liste.map((g) => (discountCents * g.umsatz) / gesamt);
     const anteile = exakt.map((x) => Math.floor(x));
-    let rest = rabattCents - anteile.reduce((s, a) => s + a, 0);
+    let rest = discountCents - anteile.reduce((s, a) => s + a, 0);
     // Reihenfolge fuer die Restcent: groesster Bruchteil zuerst, bei Gleichstand groesserer Umsatz
     const reihenfolge = liste.map((_, i) => i).sort((a, b) => (exakt[b] - anteile[b]) - (exakt[a] - anteile[a]) || liste[b].umsatz - liste[a].umsatz);
     for (let runde = 0; rest > 0 && runde < liste.length + 1; runde++) {

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

@@ -0,0 +1,86 @@
+import { ReceiptType, type ReceiptTypeKey, KeckPaymentMethod } from '../enums/index.js';
+import type { ReceiptItem } from '../models/receipt-item.js';
+import type { Voucher } from '../models/voucher.js';
+/**
+ * Zahlbetrag eines Belegs in ganzen Cent: Zwilling von `createReceipt` im
+ * Backend (Nachtrag §8), also `beleg-toepfe.belegToepfe(...).zaehlerDeltaCents`
+ * plus `zahlungen-core.wertgutscheinFlussCents`, mit den Trinkgeld-Positionen,
+ * die `tip-core.buildTipItems` aus `tip` bzw. aus `payments[].tipCents` baut.
+ *
+ * `createReceipt` hat keinen Probelauf. Unter `/v3` ist `payments[]` Pflicht,
+ * und die Summe der Zahlungen muss genau diesen Betrag treffen; wer die
+ * Zahlungen baut (Kartenterminal, Rueckgeld), rechnet ihn hier vorher aus.
+ * Trifft die Summe nicht, antwortet der Server mit `payments_sum_mismatch` und
+ * `expectedCents`, ohne eine Belegnummer zu verbrauchen; das Paket wiederholt
+ * nie selbst.
+ *
+ * **Bewusst dieselbe Rechnung wie der Server, nicht die exakte.** Das Backend
+ * rechnet die RKSV-Toepfe in Euro-Gleitkomma (Einzelpreis `Math.round(cents)/100`,
+ * je Topf `priceOne * amount` in Positionsreihenfolge, Trinkgeld-Positionen
+ * hinten angehaengt, gerundet mit `Math.round(euro * 100)`, Rabatt-Deckel in
+ * Euro). Diese Reihenfolge ist signiert und aendert sich nicht; ein exakter
+ * Zwilling wiche bei Bruchmengen auf halbem Cent ab (0,5 x 29 ct: Server 14,
+ * exakt 15). Darum steht hier dieselbe Arithmetik, Schritt fuer Schritt.
+ * Eingaben und Ergebnis sind ganze Cent; die Gleitkommazahlen leben nur
+ * innerhalb dieser Rechnung. Geprueft gegen die 20 Vertragsfaelle aus
+ * `fixtures/v3/zahlbetrag-faelle.json` und gegen mehr als 1000 mit dem echten
+ * Backend-Code erzeugte Faelle (`fixtures/receipt-due-generated.json`).
+ *
+ * **Trinkgeld-Empfaenger:** Ohne `recipients` bucht der Server das Trinkgeld
+ * auf den angemeldeten Kassen-Benutzer, und dessen Inhaber-Kennzeichen
+ * entscheidet: Inhaber-Trinkgeld ist Umsatz (anteilig auf die Saetze der Ware,
+ * mitrabattiert), Personal-Trinkgeld ein durchlaufender Posten (nie
+ * rabattiert). Das weiss nur die Kasse; darum ist `tipRecipient` Pflicht,
+ * sobald Trinkgeld ohne `recipients` vorkommt. Ohne angemeldeten Benutzer
+ * (Geraete-Schluessel) gilt `'staff'`.
+ */
+/** Wer das Trinkgeld ohne `recipients` bekommt (Kennzeichen des angemeldeten Kassen-Benutzers). */
+export type ReceiptDueTipRecipient = 'owner' | 'staff';
+/** Trinkgeld wie `tip` an `sellReceipt`: Betrag, optional mit Empfaengern samt Inhaber-Kennzeichen. */
+export type ReceiptDueTip = number | {
+    cents: number;
+    recipients?: ReadonlyArray<{
+        cents: number;
+        owner: boolean;
+    }>;
+};
+export interface ReceiptDueOptions {
+    /** Trinkgeld als Parameter `tip`; nie zugleich mit `payments[].tipCents` (`tip_conflict`). */
+    tip?: ReceiptDueTip;
+    /**
+     * Die Zahlungen, soweit sie Trinkgeld tragen (`tipCents`). Der Server bucht
+     * je Zahlart genau so, als waere `tip: { cents: Summe, paymentMethod }`
+     * geschickt worden. Andere Felder zaehlen hier nicht.
+     */
+    payments?: ReadonlyArray<{
+        method: KeckPaymentMethod | string;
+        tipCents?: number;
+    }>;
+    /** Pflicht, sobald Trinkgeld ohne `recipients` vorkommt (siehe Modulkommentar). */
+    tipRecipient?: ReceiptDueTipRecipient;
+}
+/** Die sechs RKSV-Toepfe in Cent, Namen wie am Beleg des Backends. */
+export interface ReceiptDueBuckets {
+    amountRateStandard: number;
+    amountRateReduced1: number;
+    amountRateReduced2: number;
+    amountRateZero: number;
+    amountRateSpecial: number;
+    amountRatOthers: number;
+}
+export interface ReceiptDueBreakdown {
+    /** Was die Zahlungen zusammen ergeben muessen. */
+    dueCents: number;
+    /** Delta des Umsatzzaehlers (Summe der Toepfe). */
+    counterDeltaCents: number;
+    /** Anteil der Wertgutscheine am Zahlbetrag. */
+    valueVoucherFlowCents: number;
+    /** Toepfe je auf Cent gerundet; `null` bei Start- und Nullbeleg. */
+    bucketsCents: ReceiptDueBuckets | null;
+}
+type BelegArt = ReceiptType | ReceiptTypeKey | string;
+/** Zahlbetrag in Cent, siehe Modulkommentar. */
+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 {};