@kreiseck/kasseneck-api 0.6.7

package/dist/esm/receipt/grid.js

@@ -0,0 +1,116 @@
+import { wortzeilenText } from '../printing/escpos.js';
+/**
+ * Zeichenraster: der Beleg als Zeilen mit **exakt N Zeichen** -- die einzige
+ * Wahrheit fuer Bildschirm, Bondruck und PDF. Kein Ausgabeweg rechnet
+ * Spalten selbst; wer das Raster setzt, setzt den Beleg.
+ *
+ * Regeln (fest, damit ueberall dasselbe herauskommt):
+ * - Papier 58 mm = 32 Zeichen, 80 mm = 48 (Font A); andere Breiten per Option.
+ * - Spalten in Zwoelfteln -> ganze Zeichen: `floor(N*w/12)`, der Rest an die
+ *   letzte Spalte, jede mindestens 1. Zwischen zwei Spalten steht immer
+ *   mindestens ein Leerzeichen (letztes Zeichen jeder nicht-letzten Spalte).
+ *   Die letzte Spalte endet buendig am rechten Rand.
+ * - Text/Aufdruck/Spalteninhalt bricht **wortweise** um (`wortzeilenText`,
+ *   dieselbe Regel wie der ESC/POS-Kern); ueberlange Woerter nach einem
+ *   Bindestrich, sonst hart; geschuetztes Leerzeichen bricht nie.
+ * - Fliessregel: laeuft in einer Spaltenzeile nur eine Spalte ueber die erste
+ *   Zeile hinaus, bekommt ihr Rest die volle Breite (lange Artikelnamen auf
+ *   58 mm); laufen mehrere weiter, bleibt das Raster.
+ * - Trennlinie ueber die volle Breite, Leerraum als Leerzeilen, QR als eigene
+ *   Zeile mit Nutzlast (der Zeichner setzt das Bild).
+ */
+export const ZEICHEN_JE_PAPIER = { mm58: 32, mm80: 48 };
+/** Zwoelftel -> Zeichen je Spalte (ganze Zeichen, Rest an die letzte, mindestens 1). */
+export function gridSpaltenBreiten(zwoelftel, zeichen) {
+    const out = [];
+    let vergeben = 0;
+    zwoelftel.forEach((w, i) => {
+        const letzte = i === zwoelftel.length - 1;
+        const b = letzte ? Math.max(1, zeichen - vergeben) : Math.max(1, Math.floor((zeichen * w) / 12));
+        out.push(b);
+        vergeben += b;
+    });
+    return out;
+}
+function ausrichten(text, breite, align) {
+    const t = text.length > breite ? text.slice(0, breite) : text;
+    const rest = breite - t.length;
+    if (align === 'right')
+        return ' '.repeat(rest) + t;
+    if (align === 'center') {
+        const links = Math.floor(rest / 2);
+        return ' '.repeat(links) + t + ' '.repeat(rest - links);
+    }
+    return t + ' '.repeat(rest);
+}
+const QR_PLATZHALTER = '[QR-Code]';
+/** Text hinter der ersten Umbruchzeile (die ist ein Praefix des Textes, ohne Endleerzeichen). */
+function restNach(text, erste) {
+    let i = erste.length;
+    while (i < text.length && text[i] === ' ')
+        i += 1;
+    return text.slice(i);
+}
+export function renderReceiptGrid(layout, options = {}) {
+    const zeichen = Math.max(8, Math.floor(options.zeichen ?? ZEICHEN_JE_PAPIER[layout.paperSize] ?? 32));
+    const leer = ' '.repeat(zeichen);
+    const lines = [];
+    for (const z of layout.lines) {
+        switch (z.kind) {
+            case 'text':
+                for (const t of wortzeilenText(z.text, zeichen))
+                    lines.push({ text: ausrichten(t, zeichen, z.align), kind: 'text', bold: z.bold });
+                break;
+            case 'banner':
+                for (const t of wortzeilenText(z.text, zeichen))
+                    lines.push({ text: ausrichten(t, zeichen, 'center'), kind: 'banner', bold: true, ton: z.ton });
+                break;
+            case 'rule':
+                lines.push({ text: (z.char || '-').charAt(0).repeat(zeichen), kind: 'rule', bold: false });
+                break;
+            case 'space':
+                for (let i = 0; i < Math.max(0, z.lines); i += 1)
+                    lines.push({ text: leer, kind: 'space', bold: false });
+                break;
+            case 'qr':
+                lines.push({ text: ausrichten(QR_PLATZHALTER, zeichen, 'center'), kind: 'qr', bold: false, qr: z.data });
+                break;
+            case 'columns': {
+                const breiten = gridSpaltenBreiten(z.columns.map((c) => c.width), zeichen);
+                // Inhalt jeder nicht-letzten Spalte um 1 Zeichen schmaler: garantierter Abstand.
+                const inhalt = breiten.map((b, i) => (i < breiten.length - 1 ? Math.max(1, b - 1) : b));
+                const teile = z.columns.map((c, i) => wortzeilenText(c.text, inhalt[i]));
+                // Fliessregel: laeuft nach der ersten Zeile nur noch EINE Spalte weiter (die anderen sind
+                // fertig), bekommt ihr Rest die volle Breite -- auf 58 mm sonst 18-Zeichen-Schnipsel.
+                // Laufen mehrere weiter, bleibt das Raster (sonst verschoeben sich die Nachbarn).
+                const weiterlaufend = teile.map((t, i) => (t.length > 1 ? i : -1)).filter((i) => i >= 0);
+                const fliesst = weiterlaufend.length === 1 && z.columns.length > 1;
+                const zeilen = fliesst ? 1 : Math.max(1, ...teile.map((t) => t.length));
+                for (let r = 0; r < zeilen; r += 1) {
+                    let text = '';
+                    z.columns.forEach((c, i) => {
+                        const zelle = ausrichten(teile[i][r] ?? '', inhalt[i], c.align);
+                        text += i < breiten.length - 1 ? zelle + ' '.repeat(breiten[i] - inhalt[i]) : zelle;
+                    });
+                    lines.push({ text: text.length === zeichen ? text : ausrichten(text, zeichen, 'left'), kind: 'columns', bold: false });
+                }
+                if (fliesst) {
+                    const i = weiterlaufend[0];
+                    // Rest aus dem Originaltext (nicht aus den schmal umbrochenen Stuecken), damit
+                    // Bindestrich-/Hartbrueche der schmalen Spalte nicht als Leerzeichen zurueckbleiben.
+                    const rest = restNach(z.columns[i].text, teile[i][0]);
+                    for (const t of wortzeilenText(rest, zeichen))
+                        lines.push({ text: ausrichten(t, zeichen, z.columns[i].align), kind: 'columns', bold: false });
+                }
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    return { lines, zeichen };
+}
+/** Klartext (eine Zeile je Rasterzeile) -- fuer Golden-Dateien und Logs. QR als Platzhalter. */
+export function gridAlsText(grid) {
+    return grid.lines.map((z) => z.text).join('\n');
+}

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

@@ -0,0 +1,4 @@
+export { type LayoutAlign, type LayoutColumn, type LayoutTextLine, type LayoutColumnsLine, type LayoutRuleLine, type LayoutSpaceLine, type LayoutQrLine, type LayoutLine, type ReceiptLayout, type BuildReceiptLayoutOptions, buildReceiptLayout, receiptSignatureFailed, receiptSignatureIsTest, receiptIsZero, receiptAmountsAreZero, receiptIsSmallBusinessConsistent, receiptZdaText, type Pruefangaben, AKTUELLES_REGELWERK, type LayoutBannerLine, type LayoutRegelwerk, SMALL_BUSINESS_NOTICE, formatCents, } from './layout.js';
+export { type EscPosLayoutOptions, escPosLayoutBytes } from './layout-escpos.js';
+export { type GridLine, type GridLineKind, type ReceiptGrid, type RenderReceiptGridOptions, renderReceiptGrid, gridSpaltenBreiten, gridAlsText, ZEICHEN_JE_PAPIER, } from './grid.js';
+export { type EposPrintXmlOptions, type EposDirectOptions, type EposResponse, eposPrintXml, eposXmlEscape, eposServiceUrl, eposSoapEnvelope, eposParseResponse, eposDirectPrint, eposDirectStatus } from './epos.js';

package/dist/esm/receipt/index.js

@@ -0,0 +1,4 @@
+export { buildReceiptLayout, receiptSignatureFailed, receiptSignatureIsTest, receiptIsZero, receiptAmountsAreZero, receiptIsSmallBusinessConsistent, receiptZdaText, AKTUELLES_REGELWERK, SMALL_BUSINESS_NOTICE, formatCents, } from './layout.js';
+export { escPosLayoutBytes } from './layout-escpos.js';
+export { renderReceiptGrid, gridSpaltenBreiten, gridAlsText, ZEICHEN_JE_PAPIER, } from './grid.js';
+export { eposPrintXml, eposXmlEscape, eposServiceUrl, eposSoapEnvelope, eposParseResponse, eposDirectPrint, eposDirectStatus } from './epos.js';

package/dist/esm/receipt/layout-escpos.d.ts

@@ -0,0 +1,35 @@
+import { type PosCodeTable, type PosCutMode, type PosPaperSize, type QrCorrection, type QrSize } from '../printing/index.js';
+import type { ReceiptLayout } from './layout.js';
+/**
+ * Bruecke vom Layout-Modell zu ESC/POS-Bytes — der Bondrucker-Ausgabeweg.
+ *
+ * Hier, und nur hier, wird der Belegtext **druckbar gemacht**
+ * ([escPosPrintableText]): Bondrucker sprechen eine Ein-Byte-Codepage, ein
+ * „€" oder ein Emoji im Artikelnamen laesst die Kodierung werfen und den
+ * gesamten Ausdruck ausfallen. Das Layout selbst fuehrt weiterhin echten Text
+ * — auf dem Bildschirm soll „€" stehen und nicht „EUR".
+ *
+ * Ausgenommen ist der QR-Inhalt: er ist maschinenlesbar (RKSV) und wird
+ * unveraendert uebergeben. Eine Zeichenersetzung machte den Code ungueltig;
+ * ein unerwartetes Zeichen darin soll darum auffallen und nicht still
+ * verfaelscht werden.
+ */
+export interface EscPosLayoutOptions {
+    /** Papierbreite; Vorgabe ist die des Layouts (dessen Spaltenbreiten daran haengen). */
+    paperSize?: PosPaperSize;
+    /** Codepage des Druckers, Vorgabe `CP1252`; `null` laesst die des Geraets stehen. */
+    codeTable?: PosCodeTable | null;
+    /** Papierschnitt am Ende: `true` (voll), `'partial'` oder `false`. Vorgabe `true`. */
+    cut?: boolean | PosCutMode;
+    /** Modulgroesse des QR-Codes. */
+    qrSize?: QrSize;
+    /** Fehlerkorrekturstufe des QR-Codes. */
+    qrCorrection?: QrCorrection;
+}
+/**
+ * Bytes fuer den Bondrucker -- **aus dem Zeichenraster** ([renderReceiptGrid]):
+ * jede Rasterzeile geht als fertige, exakt N Zeichen breite Textzeile raus.
+ * Keine eigene Spaltenrechnung, keine `ESC $`-Positionierung: was das Raster
+ * zeigt, druckt der Drucker (Monospace, Font A: 32/48 Zeichen).
+ */
+export declare function escPosLayoutBytes(layout: ReceiptLayout, options?: EscPosLayoutOptions): Uint8Array;

package/dist/esm/receipt/layout-escpos.js

@@ -0,0 +1,64 @@
+import { createEscPosDocument, escPosBytes, escPosCut, escPosFeed, escPosPrintableText, escPosQrCode, escPosReset, escPosText, } from '../printing/index.js';
+import { renderReceiptGrid, ZEICHEN_JE_PAPIER } from './grid.js';
+/**
+ * Druckbar gemachtes Layout: Texte durch [escPosPrintableText] (Codepage,
+ * "EUR" statt "€", Striche), damit das Raster mit den Zeichen rechnet, die
+ * wirklich aufs Papier gehen. Der QR-Inhalt bleibt unveraendert.
+ */
+function druckbaresLayout(layout) {
+    return {
+        ...layout,
+        lines: layout.lines.map((z) => {
+            switch (z.kind) {
+                case 'text': return { ...z, text: escPosPrintableText(z.text) };
+                case 'banner': return { ...z, text: escPosPrintableText(z.text) };
+                case 'columns': return { ...z, columns: z.columns.map((c) => ({ ...c, text: escPosPrintableText(c.text) })) };
+                case 'rule': return { ...z, char: escPosPrintableText(z.char) || '-' };
+                default: return z;
+            }
+        }),
+    };
+}
+/**
+ * Bytes fuer den Bondrucker -- **aus dem Zeichenraster** ([renderReceiptGrid]):
+ * jede Rasterzeile geht als fertige, exakt N Zeichen breite Textzeile raus.
+ * Keine eigene Spaltenrechnung, keine `ESC $`-Positionierung: was das Raster
+ * zeigt, druckt der Drucker (Monospace, Font A: 32/48 Zeichen).
+ */
+export function escPosLayoutBytes(layout, options = {}) {
+    const paperSize = options.paperSize ?? layout.paperSize;
+    const dokumentOptionen = { paperSize };
+    if (options.codeTable !== undefined) {
+        dokumentOptionen.codeTable = options.codeTable;
+    }
+    const doc = createEscPosDocument(dokumentOptionen);
+    escPosReset(doc);
+    const qrOptionen = { align: 'center' };
+    if (options.qrSize !== undefined)
+        qrOptionen.size = options.qrSize;
+    if (options.qrCorrection !== undefined)
+        qrOptionen.correction = options.qrCorrection;
+    const grid = renderReceiptGrid(druckbaresLayout(layout), { zeichen: ZEICHEN_JE_PAPIER[paperSize] });
+    for (const zeile of grid.lines) {
+        switch (zeile.kind) {
+            case 'space':
+                escPosFeed(doc, 1);
+                break;
+            case 'qr':
+                escPosQrCode(doc, zeile.qr ?? '', qrOptionen);
+                break;
+            case 'banner':
+                // Belegart/Warnung: fett, doppelte Hoehe; Warnungen zusaetzlich invers.
+                // Der Text ist bereits zentriert aufgefuellt (Raster).
+                escPosText(doc, zeile.text.trimEnd(), { styles: { align: 'left', bold: true, height: 2, reverse: zeile.ton === 'warnung' } });
+                break;
+            default:
+                escPosText(doc, zeile.text.trimEnd(), { styles: { align: 'left', bold: zeile.bold } });
+                break;
+        }
+    }
+    if (options.cut !== false) {
+        escPosCut(doc, options.cut === 'partial' ? 'partial' : 'full');
+    }
+    return escPosBytes(doc);
+}

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

@@ -0,0 +1,180 @@
+import { type Receipt, type ReceiptCompany } from '../models/index.js';
+import type { PosPaperSize } from '../printing/escpos.js';
+/**
+ * Beleg-Layout — der Bauplan eines Kasseneck-Belegs als reines Datenmodell.
+ *
+ * Aufbau und Reihenfolge stammen aus dem Flutter-Vorbild
+ * `kasseneck_api/lib/models/print_paper.dart` (`setKeckReceipt`). Der
+ * Unterschied: dort entstehen unmittelbar Druckerbytes, hier entsteht **eine
+ * Folge von Zeilen**. Wer sie zeichnet, entscheidet der Aufrufer — der
+ * React-Adapter (`@kreiseck/kasseneck-api/react`) fuer den Bildschirm,
+ * [escPosLayoutBytes] (`./layout-escpos.js`) fuer den Bondrucker, ein
+ * PDF-Erzeuger im Backend. Damit steht die Reihenfolge der Belegangaben genau
+ * einmal da und nicht je Ausgabeweg erneut.
+ *
+ * Kein Framework, keine Druckerabhaengigkeit, keine Bildverarbeitung: das
+ * Modell laeuft unveraendert im Browser und in Node.
+ *
+ * **Der Text im Modell ist echter Text.** Ein Euro-Zeichen ist hier ein „€",
+ * kein „EUR". Bondrucker koennen es nicht darstellen; die Ersetzung sitzt
+ * deshalb an genau einer Stelle in der ESC/POS-Bruecke und nicht hier — sonst
+ * stuende auch auf dem Bildschirm „EUR".
+ *
+ * Bewusst **nicht** enthalten: Firmenlogo und Rasterbilder (brauchen
+ * Bildverarbeitung, die im Browser anders aussieht als in Node), PDF-Erzeugung,
+ * Druckeransteuerung und die anbieterspezifischen Kartenzahlungsbloecke des
+ * Vorbilds (GP Tom, Hobex, SumUp, myPOS, Stripe).
+ */
+/** Ausrichtung einer Zeile bzw. einer Spalte. */
+export type LayoutAlign = 'left' | 'center' | 'right';
+/** Eine Spalte einer Spaltenzeile; `width` ist ein Zwoelftel-Anteil (1..12). */
+export interface LayoutColumn {
+    text: string;
+    width: number;
+    align: LayoutAlign;
+}
+/** Eine Textzeile ueber die volle Breite. */
+export interface LayoutTextLine {
+    kind: 'text';
+    text: string;
+    align: LayoutAlign;
+    bold: boolean;
+}
+/** Eine Zeile aus mehreren Spalten; die Breiten ergeben zusammen 12. */
+export interface LayoutColumnsLine {
+    kind: 'columns';
+    columns: LayoutColumn[];
+}
+/** Eine durchgehende Trennlinie aus [char]. */
+export interface LayoutRuleLine {
+    kind: 'rule';
+    char: string;
+}
+/** Leerraum von [lines] Zeilen. */
+export interface LayoutSpaceLine {
+    kind: 'space';
+    lines: number;
+}
+/** Der maschinenlesbare RKSV-Code. [data] ist die Nutzlast, unveraendert. */
+export interface LayoutQrLine {
+    kind: 'qr';
+    data: string;
+}
+/**
+ * Hervorgehobene Zeile (Belegart, Testhinweise): fett, zentriert, vom
+ * Zeichner sichtbar abgesetzt (Rahmen, invers oder Groesse). Der Text ist
+ * bereits fertig (RKSV § 11 Abs. 3: Trainings- und Stornobuchungen sind
+ * ausdruecklich als solche zu bezeichnen).
+ */
+export interface LayoutBannerLine {
+    kind: 'banner';
+    text: string;
+    /** `warnung` fuer Testkasse/Testsignatur (nicht gueltiger Beleg), sonst `belegart`. */
+    ton: 'belegart' | 'warnung';
+}
+export type LayoutLine = LayoutTextLine | LayoutColumnsLine | LayoutRuleLine | LayoutSpaceLine | LayoutQrLine | LayoutBannerLine;
+/**
+ * Version des Layout-Regelwerks. Alte Belege werden mit ihrer gespeicherten
+ * Version gesetzt.
+ * - 1: Nullbeleg reduziert mit Summenzeile „Betrag: 0,00 €“.
+ * - 2: Nullbeleg als Pruefbeleg mit Block „Prüfangaben“ (Barumsatz, Signatur,
+ *   Signaturkarte, Zertifizierungsdienst, Registrierdaten); reduziert nur,
+ *   wenn alle Betraege wirklich 0 sind. Vollbelege unveraendert.
+ */
+export type LayoutRegelwerk = 1 | 2;
+export declare const AKTUELLES_REGELWERK: LayoutRegelwerk;
+/**
+ * Registrierdaten fuer den Block „Prüfangaben“ auf Nullbelegen (Regelwerk 2).
+ * Kennt sie nur das Backend (FinanzOnline-Registrierung der Signaturkarte und
+ * der Kasse); fehlen sie, entfallen die Zeilen. Datum als „YYYY-MM-DD“ oder
+ * ISO-Zeitstempel (Wiener Kalendertag).
+ */
+export interface Pruefangaben {
+    karteRegistriertAm?: string | null;
+    kasseRegistriertAm?: string | null;
+}
+/** Der fertige Bauplan eines Belegs. */
+export interface ReceiptLayout {
+    lines: LayoutLine[];
+    /** Papierbreite, nach der die Spaltenbreiten gewaehlt wurden. */
+    paperSize: PosPaperSize;
+    /** Regelwerk, nach dem gesetzt wurde. */
+    regelwerk: LayoutRegelwerk;
+}
+export interface BuildReceiptLayoutOptions {
+    /**
+     * Papierbreite; sie bestimmt — wie im Vorbild — allein die Spaltenbreiten
+     * der USt-Tabelle. Vorgabe `mm58`.
+     */
+    paperSize?: PosPaperSize;
+    /** Layout-Regelwerk (Vorgabe: aktuelles). Unbekannt -> Fehler, nie stumm anders setzen. */
+    regelwerk?: LayoutRegelwerk;
+    /** Beleg einer Testumgebung: Rahmen „TESTKASSE — kein gültiger Beleg“ oben und unten. */
+    testKasse?: boolean;
+    /**
+     * Produktionskonto hat mit einer Test-Signatureinheit signiert: Rahmen
+     * „TESTSIGNATUR — kein gültiger Beleg“. Der Aufrufer entscheidet (er kennt
+     * das Konto); [receiptSignatureIsTest] sagt nur, OB die Signatur eine Testsignatur ist.
+     */
+    testSignatur?: boolean;
+    /** Registrierdaten fuer den Block „Prüfangaben“ (nur Nullbelege, Regelwerk 2). */
+    pruefangaben?: Pruefangaben | null;
+}
+/**
+ * Cent-Betrag als Anzeigetext: `1234` -> `"12,34"`. Die **einzige** Stelle, an
+ * der aus Cent eine Zeichenkette wird. Erwartet ganze Cent (Geld wird in
+ * diesem Paket ausnahmslos ganzzahlig gerechnet).
+ */
+export declare function formatCents(cents: number): string;
+/**
+ * Hinweis auf die Steuerbefreiung, den ein Kleinunternehmerbeleg tragen muss —
+ * ohne ihn stuende in der USt-Tabelle „D 0 %" ohne jede Begruendung, und ab
+ * 400 € greift § 11 UStG voll.
+ *
+ * Wortlaut **woertlich** aus dem Backend (`INVOICE_TAX_NOTE.smallBusiness` in
+ * functions/index.js), damit auf Beleg und Rechnung derselbe Satz steht. Er
+ * traegt einen Gedankenstrich (U+2013), kein Bindestrich; der Bondrucker
+ * bekommt ihn ueber die Ersetzung der ESC/POS-Bruecke.
+ *
+ * Weder `print_paper.dart` noch das Beleg-PDF des Backends drucken den Hinweis
+ * heute — hier liegt das Kennzeichen vor, also steht er hier.
+ *
+ * Der **Name** ist englisch wie die uebrige Oberflaeche (`DEFAULT_BASE_URL`,
+ * `formatCents`, `buildReceiptLayout`); der **Wortlaut** ist selbstverstaendlich
+ * deutsch — er steht so auf oesterreichischen Belegen.
+ */
+export declare const SMALL_BUSINESS_NOTICE = "Umsatzsteuerbefreit \u2013 Kleinunternehmer gem\u00E4\u00DF \u00A7 6 Abs. 1 Z 27 UStG.";
+/** Wurde der Beleg ohne funktionierende Signatureinheit ausgestellt? */
+export declare function receiptSignatureFailed(receipt: Receipt): boolean;
+/**
+ * Traegt der Beleg eine **Test**-Signatur? Erkannt am ZDA-Kennzeichen `AT100`
+ * im maschinenlesbaren Code (`_R1-AT100_...`) — der Testpfad der Testumgebungen.
+ * Ob das ein Problem ist, weiss nur der Aufrufer (Testkonto: normal;
+ * Produktionskonto: „TESTSIGNATUR“-Warnung).
+ */
+export declare function receiptSignatureIsTest(receipt: Pick<Receipt, 'qr'>): boolean;
+/** Ist das ein Nullbeleg (Start-, Monats-, Jahres-, Schluss-, Pruefbeleg)? */
+export declare function receiptIsZero(receipt: Receipt): boolean;
+/**
+ * Sind alle Betraege des Belegs wirklich 0? (Keine Positionen mit Wert, keine
+ * Gutscheine.) Ein Nullbeleg, der das nicht erfuellt, ist ein Datenfehler --
+ * Regelwerk 2 setzt ihn dann als normalen Beleg.
+ */
+export declare function receiptAmountsAreZero(receipt: Receipt): boolean;
+/**
+ * Zertifizierungsdienst aus der QR-Kennung `_R1-<ZDA>_` (RKSV-Detailspezifikation:
+ * AT0 geschlossenes System, AT1 A-Trust, AT2 GlobalTrust, AT3 PrimeSign,
+ * AT100 Testsignatur). Unbekannte Kennung: nur die Kennung.
+ */
+export declare function receiptZdaText(qr: string): string | null;
+/**
+ * Kleinunternehmer (§ 6 Abs. 1 Z 27 UStG, unechte Befreiung): auf dem Beleg
+ * darf keine USt stehen -- jede Position 0 %. Sagt, ob der Beleg dazu passt;
+ * das Backend weist Widersprueche beim Ausstellen ab, hier ist es die Probe.
+ */
+export declare function receiptIsSmallBusinessConsistent(receipt: Receipt): boolean;
+/**
+ * Baut das Layout eines Belegs. Reihenfolge und Spaltenbreiten folgen
+ * `print_paper.dart` (`setKeckReceipt`).
+ */
+export declare function buildReceiptLayout(receipt: Receipt, company: ReceiptCompany, options?: BuildReceiptLayoutOptions): ReceiptLayout;