@kreiseck/kasseneck-api 0.21.0 → 0.23.0

package/dist/cjs/rechnung/rechnen.js

@@ -0,0 +1,327 @@
+"use strict";
+/**
+ * Der Rechenkern der Rechnung — exakt, in ganzen Zahlen.
+ *
+ * Eine Zeile ist ein Bruch: Preis (µ€) × Menge (Tausendstel) × Rabattanteil
+ * (Hundertstel-Prozent). Multipliziert man die Skalen, ist die kleinste Einheit
+ * 10⁻¹⁷ Cent — das passt in keine Gleitkommazahl und in keine 53-Bit-Ganzzahl,
+ * also rechnet der Kern mit BigInt. Gerundet wird genau EINMAL je USt-Satz, auf
+ * dem Bruch, kaufmaennisch (halbe Einheit vom Nullpunkt weg).
+ *
+ * Warum das so streng ist: Vier Umsetzungen (Server, dieses Paket, Dart, Panel)
+ * mussten bisher dieselbe Reihenfolge von Gleitkomma-Schritten nachbauen, damit
+ * Grenzfaelle gleich runden. Mit Ganzzahlen gibt es keine Reihenfolge mehr, an
+ * der etwas auseinanderlaufen koennte.
+ *
+ * Dieser Unterpfad ist rein: kein Transport, kein Zugangsschluessel, keine
+ * Abhaengigkeit ausser Typen. Er wird im Browser gebuendelt (Panel) und im
+ * Server geladen.
+ *
+ * Spec: docs/specs/2026-09-17-rechnung-ganzzahlen-design.md § 5.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RechenFehler = exports.STEUERFREIE_FAELLE = exports.BETRAG_GRENZE_CENTS = void 0;
+exports.rund = rund;
+exports.rechnungRechnen = rechnungRechnen;
+exports.positionAusEuro = positionAusEuro;
+exports.anteiligerPreis = anteiligerPreis;
+exports.satzSchluessel = satzSchluessel;
+exports.satzText = satzText;
+exports.preisText = preisText;
+/** Skala des Zeilenbruchs: 10⁻¹⁷ Cent. */
+const E = 10n ** 17n;
+/** Hoechster Betrag je Zeile und je Rechnung: 999.999.999,99 €. */
+exports.BETRAG_GRENZE_CENTS = 99_999_999_999;
+/** Steuerfaelle, in denen die Rechnung keine Steuer ausweist: jede Zeile zaehlt zu 0 %. */
+exports.STEUERFREIE_FAELLE = Object.freeze([
+    'smallBusiness',
+    'reverseCharge',
+    'igLieferung',
+    'exportThirdCountry',
+    'domesticReverseCharge',
+    'outsideScope',
+]);
+/** Fehler des Kerns — mit Code, Feld und Index, damit die API daraus einen Feldfehler machen kann. */
+class RechenFehler extends Error {
+    code;
+    feld;
+    index;
+    constructor(code, nachricht, feld, index) {
+        super(nachricht);
+        this.name = 'RechenFehler';
+        this.code = code;
+        this.feld = feld;
+        this.index = index;
+    }
+}
+exports.RechenFehler = RechenFehler;
+/**
+ * `a / b` kaufmaennisch gerundet, halbe Einheit vom Nullpunkt weg; `b` > 0.
+ *
+ * Ohne Gleitkomma: `(2·|a| + b) / (2·b)` ist genau dann eins groesser, wenn der
+ * Rest mindestens die halbe Einheit betraegt.
+ */
+function rund(a, b) {
+    const negativ = a < 0n;
+    const betrag = negativ ? -a : a;
+    const ganz = (2n * betrag + b) / (2n * b);
+    return negativ ? -ganz : ganz;
+}
+const GRENZEN = {
+    unitPriceMicros: [0, 1_000_000_000_000],
+    quantityMilli: [-1_000_000_000_000, 1_000_000_000_000],
+    discountBp: [0, 10_000],
+    vatRateBp: [0, 10_000],
+};
+function ganzzahl(wert, feld, index) {
+    if (typeof wert !== 'number' || !Number.isInteger(wert)) {
+        throw new RechenFehler('kein_ganzzahlwert', `items[${index}].${feld} muss eine ganze Zahl sein`, feld, index);
+    }
+    const [min, max] = GRENZEN[feld];
+    if (wert < min || wert > max) {
+        throw new RechenFehler('ausserhalb', `items[${index}].${feld} liegt ausserhalb von ${min} … ${max}`, feld, index);
+    }
+    return wert;
+}
+/**
+ * Verteilt die Zeilenbetraege eines Satzes so, dass sie genau die Satzsumme
+ * ergeben. Startwert ist die kaufmaennisch gerundete Zeile; der Rest geht
+ * einzeln an die Zeilen, bei denen das Runden am meisten weggenommen (bzw.
+ * zugegeben) hat. Verglichen wird auf dem Bruch, nie in Gleitkomma; bei
+ * Gleichstand bekommt die fruehere Zeile den Cent. Eine Zeile ueber 0 bekommt
+ * nie einen Cent — sonst stuende auf dem Blatt ein Betrag, den die Position
+ * nicht hat.
+ */
+function verteile(gruppe, feld, faktor, nenner, ziel) {
+    const werte = gruppe.map((z) => {
+        const zaehler = z.L * faktor;
+        return { z, zaehler, wert: rund(zaehler, nenner) };
+    });
+    let rest = ziel - werte.reduce((s, w) => s + w.wert, 0n);
+    if (rest !== 0n) {
+        const schritt = rest > 0n ? 1n : -1n;
+        const kandidaten = werte
+            .filter((w) => w.zaehler !== 0n)
+            .sort((a, b) => {
+            const da = (a.zaehler - a.wert * nenner) * schritt;
+            const db = (b.zaehler - b.wert * nenner) * schritt;
+            if (da !== db)
+                return db > da ? 1 : -1;
+            return a.z.index - b.z.index;
+        });
+        for (let k = 0; rest !== 0n && kandidaten.length > 0; k = (k + 1) % kandidaten.length) {
+            kandidaten[k].wert += schritt;
+            rest -= schritt;
+        }
+    }
+    for (const w of werte)
+        w.z[feld] = Number(w.wert);
+}
+function rechnungRechnen(positionen, optionen) {
+    const steuerfrei = exports.STEUERFREIE_FAELLE.includes(optionen.taxScheme ?? 'normal');
+    const bruttoPreise = optionen.priceMode === 'gross' && !steuerfrei;
+    const grenze = BigInt(exports.BETRAG_GRENZE_CENTS) * E;
+    const zeilen = positionen.map((p, index) => {
+        const preis = BigInt(ganzzahl(p.unitPriceMicros, 'unitPriceMicros', index));
+        const menge = BigInt(ganzzahl(p.quantityMilli, 'quantityMilli', index));
+        const rabatt = BigInt(ganzzahl(p.discountBp ?? 0, 'discountBp', index));
+        const satz = ganzzahl(p.vatRateBp ?? 0, 'vatRateBp', index);
+        const L = preis * menge * (10000n - rabatt) * 1000000n;
+        if ((L < 0n ? -L : L) > grenze) {
+            throw new RechenFehler('amount_too_large', `items[${index}] uebersteigt ${exports.BETRAG_GRENZE_CENTS} Cent`, 'unitPriceMicros', index);
+        }
+        return { index, rateBp: steuerfrei ? 0 : satz, L, netCents: 0, grossCents: 0 };
+    });
+    const jeSatz = new Map();
+    for (const z of zeilen) {
+        const gruppe = jeSatz.get(z.rateBp);
+        if (gruppe)
+            gruppe.push(z);
+        else
+            jeSatz.set(z.rateBp, [z]);
+    }
+    const byRate = [];
+    for (const [rateBp, gruppe] of jeSatz) {
+        const r = BigInt(rateBp);
+        const S = gruppe.reduce((s, z) => s + z.L, 0n);
+        let netCents;
+        let vatCents;
+        let grossCents;
+        if (bruttoPreise) {
+            grossCents = rund(S, E);
+            netCents = rund(grossCents * 10000n, 10000n + r);
+            vatCents = grossCents - netCents;
+        }
+        else {
+            netCents = rund(S, E);
+            vatCents = rund(S * r, E * 10000n);
+            grossCents = netCents + vatCents;
+        }
+        if (bruttoPreise) {
+            verteile(gruppe, 'netCents', 10000n, E * (10000n + r), netCents);
+            verteile(gruppe, 'grossCents', 1n, E, grossCents);
+        }
+        else {
+            verteile(gruppe, 'netCents', 1n, E, netCents);
+            verteile(gruppe, 'grossCents', 10000n + r, E * 10000n, grossCents);
+        }
+        byRate.push({
+            rateBp,
+            netCents: Number(netCents),
+            vatCents: Number(vatCents),
+            grossCents: Number(grossCents),
+        });
+    }
+    byRate.sort((a, b) => b.rateBp - a.rateBp);
+    const summe = (feld) => byRate.reduce((s, r) => s + r[feld], 0);
+    const ergebnis = {
+        netCents: summe('netCents'),
+        vatCents: summe('vatCents'),
+        grossCents: summe('grossCents'),
+        byRate,
+        lines: zeilen.map((z) => ({ netCents: z.netCents, grossCents: z.grossCents, rateBp: z.rateBp })),
+    };
+    for (const feld of ['netCents', 'vatCents', 'grossCents']) {
+        if (Math.abs(ergebnis[feld]) > exports.BETRAG_GRENZE_CENTS) {
+            throw new RechenFehler('amount_too_large', `Die Rechnung uebersteigt ${exports.BETRAG_GRENZE_CENTS} Cent (${feld})`);
+        }
+    }
+    return ergebnis;
+}
+/**
+ * Wandelt eine Zahl ueber ihren kuerzesten Dezimaltext in eine Ganzzahl mit
+ * `stellen` Nachkommastellen. Kein Gleitkomma-Rechnen: `0.1 * 1000` ist
+ * 100.00000000000001, `String(0.1)` dagegen genau "0.1". Mehr Stellen als
+ * erlaubt ergeben `null` — auch Gleitkomma-Rauschen wie 0.30000000000000004,
+ * das mit 17 Stellen dasteht.
+ */
+function ganzAusDezimaltext(wert, stellen) {
+    if (typeof wert !== 'number' || !Number.isFinite(wert))
+        return null;
+    const treffer = /^(-?)(\d+)(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/.exec(String(wert));
+    if (!treffer)
+        return null;
+    const [, vorzeichen = '', ganzTeil = '0', bruchTeil = '', hoch = '0'] = treffer;
+    const verschiebung = Number(hoch);
+    let ziffern = `${ganzTeil}${bruchTeil}`;
+    let nachkomma = bruchTeil.length - verschiebung;
+    if (nachkomma < 0) {
+        ziffern += '0'.repeat(-nachkomma);
+        nachkomma = 0;
+    }
+    if (nachkomma > stellen) {
+        // Nur echte Nullen am Ende duerfen wegfallen (1.20 bei 1 Stelle).
+        const zuviel = nachkomma - stellen;
+        if (!/^0+$/.test(ziffern.slice(-zuviel)))
+            return null;
+        ziffern = ziffern.slice(0, -zuviel);
+        nachkomma = stellen;
+    }
+    const skaliert = `${ziffern}${'0'.repeat(stellen - nachkomma)}`;
+    const zahl = Number(`${vorzeichen}${skaliert}`);
+    return Number.isSafeInteger(zahl) ? zahl : null;
+}
+const EURO_FELDER = ['unitPrice', 'quantity', 'vatRate', 'discountPct'];
+/**
+ * Euro-Position → Ganzzahl-Form, verlustfrei oder mit Grund abgelehnt. Die
+ * EINE Stelle, die das tut: Panel (beim Lesen), SEPA-Lauf, Umrechnungsskript
+ * und das Festschreiben benutzen alle diese Funktion, damit niemand eine
+ * zweite Auslegung baut.
+ *
+ * Eine Position, die schon `unitPriceMicros` traegt, kommt unveraendert
+ * zurueck — die Funktion ist die Formweiche, nicht eine blinde Umrechnung.
+ *
+ * Fehlende Menge und fehlender Satz gelten als 0, weil der Server bisher so
+ * abgerechnet hat. Ein fehlender Preis dagegen ist NIE 0: sonst wuerde eine
+ * Position, der nur der Preis fehlt, still zur 0-€-Zeile.
+ */
+function positionAusEuro(item) {
+    if (typeof item.unitPriceMicros === 'number') {
+        return { ok: true, position: item };
+    }
+    const roh = item.unitPrice;
+    if (typeof roh !== 'number' || !Number.isFinite(roh)) {
+        return { ok: false, feld: 'unitPrice', grund: 'kein_zahlwert' };
+    }
+    const micros = ganzAusDezimaltext(Math.abs(roh), 6);
+    if (micros === null)
+        return { ok: false, feld: 'unitPrice', grund: 'nachkommastellen' };
+    if (micros > GRENZEN.unitPriceMicros[1])
+        return { ok: false, feld: 'unitPrice', grund: 'ausserhalb' };
+    const zahl = (feld, stellen, max) => {
+        const w = item[feld];
+        if (w === undefined || w === null)
+            return { ok: true, wert: 0 };
+        if (typeof w !== 'number' || !Number.isFinite(w))
+            return { ok: false, grund: 'kein_zahlwert' };
+        const ganz = ganzAusDezimaltext(w, stellen);
+        if (ganz === null)
+            return { ok: false, grund: 'nachkommastellen' };
+        if (ganz < (feld === 'quantity' ? -max : 0) || ganz > max)
+            return { ok: false, grund: 'ausserhalb' };
+        return { ok: true, wert: ganz };
+    };
+    const menge = zahl('quantity', 3, GRENZEN.quantityMilli[1]);
+    if (!menge.ok)
+        return { ok: false, feld: 'quantity', grund: menge.grund };
+    const satz = zahl('vatRate', 2, 10_000);
+    if (!satz.ok)
+        return { ok: false, feld: 'vatRate', grund: satz.grund };
+    const rabatt = zahl('discountPct', 2, 10_000);
+    if (!rabatt.ok)
+        return { ok: false, feld: 'discountPct', grund: rabatt.grund };
+    const rest = { ...item };
+    for (const feld of EURO_FELDER)
+        delete rest[feld];
+    return {
+        ok: true,
+        position: {
+            ...rest,
+            unitPriceMicros: micros,
+            quantityMilli: roh < 0 ? -menge.wert : menge.wert,
+            discountBp: rabatt.wert,
+            vatRateBp: satz.wert,
+        },
+    };
+}
+/**
+ * Anteiliger Preis fuer einen Teilzeitraum (erste Rechnung eines Abos).
+ * War der Ursprungspreis centgenau, bleibt auch der Anteil centgenau — sonst
+ * stuende auf der ersten Rechnung ein Preis mit sechs Stellen, wo bisher zwei
+ * standen.
+ */
+function anteiligerPreis(unitPriceMicros, monate, intervall) {
+    const micros = BigInt(unitPriceMicros);
+    const anteil = rund(micros * BigInt(monate), BigInt(intervall));
+    if (unitPriceMicros % 10_000 !== 0)
+        return Number(anteil);
+    return Number(rund(anteil, 10000n) * 10000n);
+}
+/**
+ * Schluessel eines USt-Satzes in den gespeicherten Maps (`creditedCents.byRate`,
+ * `invoice_stats.vatByRate`): der Prozenttext mit Punkt, genau wie
+ * `String(satz)` ihn bisher gebildet hat. NICHT fuer die Anzeige — dafuer gibt
+ * es `satzText`.
+ */
+function satzSchluessel(rateBp) {
+    return String(rateBp / 100);
+}
+/** Ein USt-Satz fuer die Anzeige: oesterreichisch mit Komma, ohne nachlaufende Nullen. */
+function satzText(rateBp) {
+    return satzSchluessel(rateBp).replace('.', ',');
+}
+/**
+ * Ein Einzelpreis fuer die Anzeige: mindestens zwei, hoechstens sechs
+ * Nachkommastellen, Tausenderpunkt, Komma als Trennzeichen — in jeder Sprache
+ * oesterreichisch, wie die Betraege auf dem Blatt.
+ */
+function preisText(unitPriceMicros) {
+    const negativ = unitPriceMicros < 0;
+    const betrag = Math.abs(unitPriceMicros);
+    const ganz = Math.trunc(betrag / 1_000_000);
+    let bruch = String(betrag % 1_000_000).padStart(6, '0');
+    while (bruch.length > 2 && bruch.endsWith('0'))
+        bruch = bruch.slice(0, -1);
+    const mitPunkten = String(ganz).replace(/\B(?=(\d{3})+(?!\d))/g, '.');
+    return `${negativ ? '-' : ''}${mitPunkten},${bruch}`;
+}

package/dist/cjs/rechnung/summen.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Summen einer Rechnung vorab rechnen — genau so, wie der Server sie beim
+ * Ausstellen rechnet. Fuer Shops, die kassieren, bevor die Rechnung entsteht,
+ * und denselben Betrag brauchen, den die Rechnung spaeter ausweist.
+ *
+ * Die Regel (je USt-Satz, Betraege in Cent, kaufmaennisch gerundet):
+ *
+ * | Modus   | Netto                          | USt                        | Brutto             |
+ * |---------|--------------------------------|----------------------------|--------------------|
+ * | `net`   | round(Σ Zeilen)                | round(Σ Zeilen × Satz/100) | Netto + USt        |
+ * | `gross` | round(B × 100 / (100 + Satz))  | B − Netto                  | B = round(Σ Zeilen)|
+ *
+ * Zeile = Einzelpreis × Menge × (1 − Rabatt/100), ungerundet. Im Brutto-Modus
+ * ist das Brutto der vereinbarte Preis und bleibt, wie die Zeilen es ergeben.
+ * Bei einem steuerfreien Steuerfall zaehlt jede Zeile zu 0 %.
+ *
+ * `fixtures/rechnung-summen.json` haelt die Prueffaelle; Backend und
+ * Dart-Zwilling pruefen gegen dieselbe Datei. Verbindlich bleibt, was der
+ * Server rechnet — mit `previewInvoice` laesst sich das vorab abfragen.
+ */
+import type { InvoiceTotals } from './typen.js';
+import type { PriceMode, TaxScheme } from './vertrag.js';
+import { STEUERFREIE_FAELLE } from './rechnen.js';
+/** Aus dem Kern uebernommen, damit Kern und Huelle nie auseinanderlaufen. */
+export { STEUERFREIE_FAELLE };
+/** Was fuer die Summe zaehlt — `InvoiceItemInput` passt unveraendert. */
+export interface SummenPosition {
+    quantity: number;
+    unitPriceCents: number;
+    vatRate: number;
+    discountPct?: number;
+}
+/**
+ * Netto, USt und Brutto einer Rechnung in Cent, je Satz absteigend — dieselbe
+ * Form wie `invoice.totals` in den Antworten.
+ *
+ * `taxScheme` ist der Steuerfall der Rechnung; ohne Angabe `normal`. Leitet der
+ * Server einen steuerfreien Fall ab (etwa eine ig. Lieferung), gehoert dieser
+ * Fall hierher — sonst rechnet die Funktion Steuer, die die Rechnung nicht
+ * ausweist.
+ */
+export declare function rechnungSummen(items: readonly SummenPosition[], priceMode: PriceMode, taxScheme?: TaxScheme): InvoiceTotals;

package/dist/cjs/rechnung/summen.js

@@ -0,0 +1,74 @@
+"use strict";
+/**
+ * Summen einer Rechnung vorab rechnen — genau so, wie der Server sie beim
+ * Ausstellen rechnet. Fuer Shops, die kassieren, bevor die Rechnung entsteht,
+ * und denselben Betrag brauchen, den die Rechnung spaeter ausweist.
+ *
+ * Die Regel (je USt-Satz, Betraege in Cent, kaufmaennisch gerundet):
+ *
+ * | Modus   | Netto                          | USt                        | Brutto             |
+ * |---------|--------------------------------|----------------------------|--------------------|
+ * | `net`   | round(Σ Zeilen)                | round(Σ Zeilen × Satz/100) | Netto + USt        |
+ * | `gross` | round(B × 100 / (100 + Satz))  | B − Netto                  | B = round(Σ Zeilen)|
+ *
+ * Zeile = Einzelpreis × Menge × (1 − Rabatt/100), ungerundet. Im Brutto-Modus
+ * ist das Brutto der vereinbarte Preis und bleibt, wie die Zeilen es ergeben.
+ * Bei einem steuerfreien Steuerfall zaehlt jede Zeile zu 0 %.
+ *
+ * `fixtures/rechnung-summen.json` haelt die Prueffaelle; Backend und
+ * Dart-Zwilling pruefen gegen dieselbe Datei. Verbindlich bleibt, was der
+ * Server rechnet — mit `previewInvoice` laesst sich das vorab abfragen.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STEUERFREIE_FAELLE = void 0;
+exports.rechnungSummen = rechnungSummen;
+const rechnen_js_1 = require("./rechnen.js");
+Object.defineProperty(exports, "STEUERFREIE_FAELLE", { enumerable: true, get: function () { return rechnen_js_1.STEUERFREIE_FAELLE; } });
+/** Auf Cent gerundete Euro — dieselbe Rundung wie am Server (halber Cent vom Nullpunkt weg). */
+function euroRund(n) {
+    return ((n < 0 ? -1 : 1) * Math.round((Math.abs(n) + Number.EPSILON) * 100)) / 100;
+}
+const euroZuCent = (euro) => Math.round(euroRund(euro) * 100) || 0;
+/** Ganze Cent kaufmaennisch; ein Gleitkomma-Rest wie x,4999999… zaehlt als halber Cent. */
+function centRund(x) {
+    const betrag = Math.round(Math.abs(x) * 1e6) / 1e6;
+    return (x < 0 ? -1 : 1) * Math.round(betrag) || 0;
+}
+/**
+ * Netto, USt und Brutto einer Rechnung in Cent, je Satz absteigend — dieselbe
+ * Form wie `invoice.totals` in den Antworten.
+ *
+ * `taxScheme` ist der Steuerfall der Rechnung; ohne Angabe `normal`. Leitet der
+ * Server einen steuerfreien Fall ab (etwa eine ig. Lieferung), gehoert dieser
+ * Fall hierher — sonst rechnet die Funktion Steuer, die die Rechnung nicht
+ * ausweist.
+ */
+function rechnungSummen(items, priceMode, taxScheme = 'normal') {
+    const steuerfrei = rechnen_js_1.STEUERFREIE_FAELLE.includes(taxScheme);
+    const bruttoPreise = priceMode === 'gross' && !steuerfrei;
+    // Ungerundete Zeilen je Satz, in Euro wie am Server.
+    const jeSatz = new Map();
+    for (const p of items) {
+        const satz = steuerfrei ? 0 : p.vatRate;
+        const zeile = (p.unitPriceCents / 100) * p.quantity * (1 - (p.discountPct ?? 0) / 100);
+        jeSatz.set(satz, (jeSatz.get(satz) ?? 0) + zeile);
+    }
+    const byRate = [];
+    for (const [rate, roh] of jeSatz) {
+        let netCents;
+        let vatCents;
+        if (bruttoPreise) {
+            const grossCents = euroZuCent(roh);
+            netCents = centRund((grossCents * 100) / (100 + rate));
+            vatCents = grossCents - netCents;
+        }
+        else {
+            netCents = euroZuCent(roh);
+            vatCents = euroZuCent((roh * rate) / 100);
+        }
+        byRate.push({ rate, netCents, vatCents, grossCents: netCents + vatCents });
+    }
+    byRate.sort((a, b) => b.rate - a.rate);
+    const summe = (feld) => byRate.reduce((s, r) => s + r[feld], 0);
+    return { netCents: summe('netCents'), vatCents: summe('vatCents'), grossCents: summe('grossCents'), byRate };
+}

package/dist/cjs/rechnung/texte.d.ts

@@ -35,8 +35,12 @@ declare const DE: {
     readonly 'pdf.tabelle.ust': "UST";
     readonly 'pdf.tabelle.einzelNetto': "EINZEL NETTO";
     readonly 'pdf.tabelle.betragNetto': "BETRAG NETTO";
+    readonly 'pdf.tabelle.einzelBrutto': "EINZEL BRUTTO";
+    readonly 'pdf.tabelle.betragBrutto': "BETRAG BRUTTO";
+    readonly 'pdf.position.rabatt': "abzüglich {prozent} % Rabatt";
     readonly 'pdf.summe.zwischensumme': "Zwischensumme netto";
     readonly 'pdf.summe.umsatzsteuer': "Umsatzsteuer {satz}%";
+    readonly 'pdf.summe.darinUst': "darin {satz}% USt von {netto} netto";
     readonly 'pdf.summe.gesamt.rechnung': "Gesamtbetrag";
     readonly 'pdf.summe.gesamt.gutschrift': "Gutschriftsbetrag";
     readonly 'steuer.kleinunternehmer': "Gemäß § 6 Abs. 1 Z 27 UStG wird keine Umsatzsteuer verrechnet (Kleinunternehmer).";

package/dist/cjs/rechnung/texte.js

@@ -24,8 +24,12 @@ const DE = {
     'pdf.tabelle.ust': 'UST',
     'pdf.tabelle.einzelNetto': 'EINZEL NETTO',
     'pdf.tabelle.betragNetto': 'BETRAG NETTO',
+    'pdf.tabelle.einzelBrutto': 'EINZEL BRUTTO',
+    'pdf.tabelle.betragBrutto': 'BETRAG BRUTTO',
+    'pdf.position.rabatt': 'abzüglich {prozent} % Rabatt',
     'pdf.summe.zwischensumme': 'Zwischensumme netto',
     'pdf.summe.umsatzsteuer': 'Umsatzsteuer {satz}%',
+    'pdf.summe.darinUst': 'darin {satz}% USt von {netto} netto',
     'pdf.summe.gesamt.rechnung': 'Gesamtbetrag',
     'pdf.summe.gesamt.gutschrift': 'Gutschriftsbetrag',
     'steuer.kleinunternehmer': 'Gemäß § 6 Abs. 1 Z 27 UStG wird keine Umsatzsteuer verrechnet (Kleinunternehmer).',
@@ -230,8 +234,12 @@ const EN = {
     'pdf.tabelle.ust': 'VAT',
     'pdf.tabelle.einzelNetto': 'UNIT NET',
     'pdf.tabelle.betragNetto': 'AMOUNT NET',
+    'pdf.tabelle.einzelBrutto': 'UNIT GROSS',
+    'pdf.tabelle.betragBrutto': 'AMOUNT GROSS',
+    'pdf.position.rabatt': 'less {prozent}% discount',
     'pdf.summe.zwischensumme': 'Subtotal net',
     'pdf.summe.umsatzsteuer': 'VAT {satz}%',
+    'pdf.summe.darinUst': 'incl. {satz}% VAT on {netto} net',
     'pdf.summe.gesamt.rechnung': 'Total',
     'pdf.summe.gesamt.gutschrift': 'Credit total',
     'steuer.kleinunternehmer': 'No VAT charged pursuant to § 6 (1) no. 27 UStG (small business exemption).',

package/dist/cjs/rechnung/typen.d.ts

@@ -146,7 +146,7 @@ export interface InvoicePayment {
 }
 /**
  * Ein Hinweis zu einer erfolgreichen Antwort — kein Fehler, sondern etwas,
- * das der Aufrufer wissen sollte (heute nur `cash_receipt_required`).
+ * das der Aufrufer wissen sollte. Die Codes stehen in `INVOICE_NOTICE_CODES`.
  */
 export interface InvoiceNotice {
     code: InvoiceNoticeCode;
@@ -156,7 +156,11 @@ export interface RecordPaymentResult {
     invoice: Invoice;
     payment: InvoicePayment;
     replayed: boolean;
-    notice?: InvoiceNotice;
+    /**
+     * Hinweise zu dieser Zahlung — eine **Liste** wie bei `issueInvoice`
+     * (bis 0.21.0 ein einzelnes Objekt). Fehlt, wenn es keinen gibt.
+     */
+    notice?: InvoiceNotice[];
 }
 export interface CancelInvoiceRequest {
     idempotencyKey: string;
@@ -167,15 +171,23 @@ export interface CancelInvoiceRequest {
 export interface CreditNoteRequest extends CancelInvoiceRequest {
     items: InvoiceItemInput[];
 }
+/**
+ * Summen einer Rechnung in Cent, **immer positiv** — auch bei einer Gutschrift
+ * (`docType: 'GU'`); das Vorzeichen steht im Belegtyp, nicht im Betrag.
+ * Gerechnet wird je Satz wie in [rechnungSummen].
+ */
 export interface InvoiceTotals {
     netCents: number;
     vatCents: number;
     grossCents: number;
-    byRate: {
-        rate: number;
-        netCents: number;
-        vatCents: number;
-    }[];
+    /** Je USt-Satz, absteigend. `grossCents` ist `netCents + vatCents` (seit 0.22.0 mitgeliefert). */
+    byRate: InvoiceRateTotals[];
+}
+export interface InvoiceRateTotals {
+    rate: number;
+    netCents: number;
+    vatCents: number;
+    grossCents: number;
 }
 export interface EInvoiceStatus {
     level: string;
@@ -299,6 +311,38 @@ export interface IssueResult {
      */
     notice?: InvoiceNotice[];
 }
+/**
+ * Was `issueInvoice` mit dieser Anfrage ausstellen wuerde — ohne Nummer, ohne
+ * Dokument, ohne Zahlung. Der Probelauf prueft wie das Ausstellen (Einrichtung,
+ * Kunde, Steuerfall, Pflichtangaben, Marke, Zahlung) und scheitert mit
+ * denselben Fehlercodes.
+ */
+export interface InvoicePreview {
+    docType: 'RE';
+    /** Heutiger Wiener Tag — der Tag, den eine sofort ausgestellte Rechnung truege. */
+    invoiceDate: string;
+    dueDate: string | null;
+    customerId: string | null;
+    /** Der abgeleitete Steuerfall. */
+    taxScheme: TaxScheme;
+    /** Warum dieser Fall gilt (z. B. `customer_country_eu_with_vat_id`). */
+    taxSchemeReason: string;
+    reverseChargeReason: ReverseChargeReason | null;
+    taxCountry: string;
+    priceMode: PriceMode;
+    totals: InvoiceTotals;
+    language: InvoiceLanguage;
+    brand: {
+        id: string | null;
+        name: string | null;
+    } | null;
+    einvoice: EInvoiceStatus;
+}
+export interface PreviewResult {
+    preview: InvoicePreview;
+    /** Dieselben Hinweise, die das Ausstellen liefern wuerde. */
+    notice?: InvoiceNotice[];
+}
 export interface CancelResult {
     creditNote: Invoice;
     original: {

package/dist/cjs/rechnung/vertrag.d.ts

@@ -24,7 +24,7 @@ export type RechnungAufruf = (typeof RECHNUNG_AUFRUFE)[number];
  * Stabile Fehlercodes. Das Fremdsystem verzweigt am Code, der Text darf sich
  * aendern. `validation` traegt zusaetzlich `errors: [{ field, message }]`.
  */
-export declare const INVOICE_ERROR_CODES: readonly ["validation", "idempotency_conflict", "module_inactive", "customer_not_found", "customer_exists", "short_code_taken", "short_code_immutable", "recipient_required", "invoice_requirements_missing", "invoice_not_found", "invoice_ambiguous", "not_cancellable", "partial_credit_exists", "credit_exceeds_invoice", "einvoice_incomplete", "invoice_api_not_enabled", "invoice_setup_incomplete", "language_not_allowed", "brand_not_found", "not_payable", "payment_exceeds_invoice", "tax_scheme_mismatch", "vat_rate_not_in_country", "reverse_charge_reason_required", "reverse_charge_threshold", "mixed_supply_not_allowed", "oss_not_enabled"];
+export declare const INVOICE_ERROR_CODES: readonly ["validation", "idempotency_conflict", "module_inactive", "customer_not_found", "customer_exists", "short_code_taken", "short_code_immutable", "recipient_required", "invoice_requirements_missing", "invoice_not_found", "invoice_ambiguous", "not_cancellable", "partial_credit_exists", "credit_exceeds_invoice", "einvoice_incomplete", "invoice_api_not_enabled", "invoice_setup_incomplete", "language_not_allowed", "brand_not_found", "not_payable", "payment_exceeds_invoice", "tax_scheme_mismatch", "vat_rate_not_in_country", "reverse_charge_reason_required", "reverse_charge_threshold", "mixed_supply_not_allowed", "oss_not_enabled", "einvoice_unavailable", "amount_too_large"];
 export type InvoiceErrorCode = (typeof INVOICE_ERROR_CODES)[number];
 /** Gruende einer Gutschrift. Der Server druckt den deutschen Anzeigetext. */
 export declare const CREDIT_NOTE_REASONS: readonly ["cancellation", "price_reduction", "return", "incorrect_invoice", "other"];

package/dist/cjs/rechnung/vertrag.js

@@ -69,6 +69,8 @@ exports.INVOICE_ERROR_CODES = [
     'reverse_charge_threshold',
     'mixed_supply_not_allowed',
     'oss_not_enabled',
+    'einvoice_unavailable', // zu dieser Rechnung entsteht keine E-Rechnung, Grund in `reason`
+    'amount_too_large', // Betrag ueber der Grenze des Ganzzahlkerns; erst ab dessen Umstieg gesendet
 ];
 /** Gruende einer Gutschrift. Der Server druckt den deutschen Anzeigetext. */
 exports.CREDIT_NOTE_REASONS = [
@@ -420,6 +422,12 @@ exports.RECHNUNG_ANFRAGEN = Object.freeze({
          * und ein sofort geholtes PDF Zahlungsinformationen traegt.
          */
         payment: { typ: 'object', pflicht: false, felder: exports.PAYMENT_FELDER },
+        /**
+         * Probelauf: alles pruefen und rechnen wie beim Ausstellen, aber nichts
+         * festschreiben — keine Nummer, kein Dokument, keine Zahlung, kein
+         * Idempotenz-Eintrag. Die Antwort traegt `preview` statt `invoice`.
+         */
+        dryRun: { typ: 'boolean', pflicht: false },
     },
     cancelInvoice: {
         idempotencyKey: idempotencyKey(true),

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

@@ -87,7 +87,6 @@ export declare function causeDigest(ursache: unknown, geheimnisse: readonly stri
  * demselben Grund **keinen** Vorgabewert.
  */
 export declare function fehlerDetails(daten: unknown, geheimnisse: readonly string[]): Record<string, unknown>;
-/** Fachlicher Fehler: HTTP 200, aber `status: 'error'` im Rumpf. */
 export declare class KasseneckApiError extends Error {
     readonly name = "KasseneckApiError";
     /** Aufgerufene Backend-Funktion, z. B. `createReceipt`. */

package/dist/esm/client/errors.js

@@ -164,6 +164,29 @@ function sieben(wert, geheimnisse, tiefe) {
     return raus;
 }
 /** Fachlicher Fehler: HTTP 200, aber `status: 'error'` im Rumpf. */
+/**
+ * Die Feldfehler einer Pruefantwort (`errors: [{ field, message }]`) als
+ * Anhang der Fehlermeldung — sonst stuende im Log nur „Bitte Eingaben
+ * pruefen." und niemand wuesste, welches Feld gemeint ist. Hoechstens fuenf;
+ * vollstaendig bleiben sie in `details.errors`.
+ */
+function feldHinweis(details) {
+    const roh = details['errors'];
+    if (!Array.isArray(roh))
+        return '';
+    const teile = [];
+    for (const e of roh) {
+        if (e === null || typeof e !== 'object')
+            continue;
+        const { field, message } = e;
+        if (typeof field === 'string' && typeof message === 'string')
+            teile.push(`${field}: ${message}`);
+    }
+    if (!teile.length)
+        return '';
+    const mehr = teile.length > 5 ? ` (+${teile.length - 5} weitere)` : '';
+    return ` [${teile.slice(0, 5).join('; ')}${mehr}]`;
+}
 export class KasseneckApiError extends Error {
     name = 'KasseneckApiError';
     /** Aufgerufene Backend-Funktion, z. B. `createReceipt`. */
@@ -187,7 +210,7 @@ export class KasseneckApiError extends Error {
      */
     details;
     constructor(functionName, serverMessage, details = {}, code) {
-        super(`${functionName} fehlgeschlagen: ${serverMessage}`);
+        super(`${functionName} fehlgeschlagen: ${serverMessage}${feldHinweis(details)}`);
         this.functionName = functionName;
         this.serverMessage = serverMessage;
         this.details = details;