@kreiseck/kasseneck-api 0.22.0 → 0.23.0

package/dist/esm/rechnung/index.js

@@ -16,4 +16,5 @@ export { istRechnungFehler, rechnungFehlerCode, rechnungFeldFehler, } from './fe
 export { cancelInvoice, createCreditNote, createCustomer, getCustomer, getInvoice, getInvoicePdf, getInvoiceSetupStatus, getInvoiceXml, issueInvoice, listBrands, listInvoices, previewInvoice, recordInvoicePayment, searchCustomers, updateCustomer, } from './endpunkte.js';
 export { RECHNUNG_TEXTE, rechnungText } from './texte.js';
 export { rechnungSummen, STEUERFREIE_FAELLE } from './summen.js';
+export { anteiligerPreis, BETRAG_GRENZE_CENTS, positionAusEuro, preisText, RechenFehler, rechnungRechnen, rund, satzSchluessel, satzText, } from './rechnen.js';
 export { RECHNUNG_VERTRAG_VERSION, RECHNUNG_AUFRUFE, INVOICE_ERROR_CODES, CREDIT_NOTE_REASONS, TAX_SCHEMES, PRICE_MODES, VAT_RATES, CUSTOMER_TYPES, INVOICE_LIST_STATUS, DOC_TYPES, EINVOICE_FORMATS, INVOICE_LANGUAGES, INVOICE_PAYMENT_METHODS, ITEM_KINDS, REVERSE_CHARGE_REASONS, INVOICE_NOTICE_CODES, INVOICE_UNITS, RECHNUNG_EINHEITEN_CODES, INVOICE_SETUP_REQUIREMENTS, KUNDE_FELDER, POSITION_FELDER, RECHNUNG_ANFRAGEN, RECHNUNG_GENAU_EINS, RECHNUNG_MINDESTENS_EINS, } from './vertrag.js';

package/dist/esm/rechnung/rechnen.d.ts

@@ -0,0 +1,123 @@
+/**
+ * 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.
+ */
+import type { PriceMode, TaxScheme } from './vertrag.js';
+/** Hoechster Betrag je Zeile und je Rechnung: 999.999.999,99 €. */
+export declare const BETRAG_GRENZE_CENTS = 99999999999;
+/** Steuerfaelle, in denen die Rechnung keine Steuer ausweist: jede Zeile zaehlt zu 0 %. */
+export declare const STEUERFREIE_FAELLE: readonly TaxScheme[];
+/** Eine Position in gespeicherter Form — alle Werte ganzzahlig. */
+export interface RechenPosition {
+    /** Einzelpreis in Millionstel Euro, 0 … 10¹². */
+    unitPriceMicros: number;
+    /** Menge in Tausendstel; negativ = Abzugszeile, 0 = Textzeile. */
+    quantityMilli: number;
+    /** Rabatt in Hundertstel-Prozent, 0 … 10000 (ohne Angabe 0). */
+    discountBp?: number;
+    /** USt-Satz in Hundertstel-Prozent, 0 … 10000 (ohne Angabe 0). */
+    vatRateBp?: number;
+}
+export interface RechenOptionen {
+    priceMode: PriceMode;
+    /** Ohne Angabe `normal`. */
+    taxScheme?: TaxScheme;
+}
+export interface SatzSumme {
+    rateBp: number;
+    netCents: number;
+    vatCents: number;
+    grossCents: number;
+}
+export interface ZeilenBetrag {
+    netCents: number;
+    grossCents: number;
+    /** Der Satz, mit dem die Zeile gerechnet wurde (bei steuerfreiem Fall 0). */
+    rateBp: number;
+}
+export interface RechenErgebnis {
+    netCents: number;
+    vatCents: number;
+    grossCents: number;
+    /** Absteigend nach `rateBp`. */
+    byRate: SatzSumme[];
+    /** Je Position, in der Reihenfolge der Eingabe. */
+    lines: ZeilenBetrag[];
+}
+export type RechenFehlerCode = 'amount_too_large' | 'kein_ganzzahlwert' | 'ausserhalb';
+/** Fehler des Kerns — mit Code, Feld und Index, damit die API daraus einen Feldfehler machen kann. */
+export declare class RechenFehler extends Error {
+    readonly code: RechenFehlerCode;
+    readonly feld?: string;
+    readonly index?: number;
+    constructor(code: RechenFehlerCode, nachricht: string, feld?: string, index?: number);
+}
+/**
+ * `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.
+ */
+export declare function rund(a: bigint, b: bigint): bigint;
+export declare function rechnungRechnen(positionen: readonly RechenPosition[], optionen: RechenOptionen): RechenErgebnis;
+export type UmwandlungsGrund = 'kein_zahlwert' | 'nachkommastellen' | 'ausserhalb';
+export type Umwandlung = {
+    ok: true;
+    position: RechenPosition & Record<string, unknown>;
+} | {
+    ok: false;
+    feld: 'unitPrice' | 'quantity' | 'vatRate' | 'discountPct';
+    grund: UmwandlungsGrund;
+};
+/**
+ * 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.
+ */
+export declare function positionAusEuro(item: Record<string, unknown>): Umwandlung;
+/**
+ * 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.
+ */
+export declare function anteiligerPreis(unitPriceMicros: number, monate: number, intervall: number): number;
+/**
+ * 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`.
+ */
+export declare function satzSchluessel(rateBp: number): string;
+/** Ein USt-Satz fuer die Anzeige: oesterreichisch mit Komma, ohne nachlaufende Nullen. */
+export declare function satzText(rateBp: number): string;
+/**
+ * Ein Einzelpreis fuer die Anzeige: mindestens zwei, hoechstens sechs
+ * Nachkommastellen, Tausenderpunkt, Komma als Trennzeichen — in jeder Sprache
+ * oesterreichisch, wie die Betraege auf dem Blatt.
+ */
+export declare function preisText(unitPriceMicros: number): string;

package/dist/esm/rechnung/rechnen.js

@@ -0,0 +1,316 @@
+/**
+ * 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.
+ */
+/** Skala des Zeilenbruchs: 10⁻¹⁷ Cent. */
+const E = 10n ** 17n;
+/** Hoechster Betrag je Zeile und je Rechnung: 999.999.999,99 €. */
+export const BETRAG_GRENZE_CENTS = 99_999_999_999;
+/** Steuerfaelle, in denen die Rechnung keine Steuer ausweist: jede Zeile zaehlt zu 0 %. */
+export const 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. */
+export 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;
+    }
+}
+/**
+ * `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.
+ */
+export 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);
+}
+export function rechnungRechnen(positionen, optionen) {
+    const steuerfrei = STEUERFREIE_FAELLE.includes(optionen.taxScheme ?? 'normal');
+    const bruttoPreise = optionen.priceMode === 'gross' && !steuerfrei;
+    const grenze = BigInt(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 ${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]) > BETRAG_GRENZE_CENTS) {
+            throw new RechenFehler('amount_too_large', `Die Rechnung uebersteigt ${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.
+ */
+export 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.
+ */
+export 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`.
+ */
+export function satzSchluessel(rateBp) {
+    return String(rateBp / 100);
+}
+/** Ein USt-Satz fuer die Anzeige: oesterreichisch mit Komma, ohne nachlaufende Nullen. */
+export 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.
+ */
+export 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/esm/rechnung/summen.d.ts

@@ -20,6 +20,9 @@
  */
 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;
@@ -27,8 +30,6 @@ export interface SummenPosition {
     vatRate: number;
     discountPct?: number;
 }
-/** Steuerfaelle, in denen die Rechnung keine Steuer ausweist: jede Zeile zaehlt zu 0 %. */
-export declare const STEUERFREIE_FAELLE: readonly TaxScheme[];
 /**
  * Netto, USt und Brutto einer Rechnung in Cent, je Satz absteigend — dieselbe
  * Form wie `invoice.totals` in den Antworten.

package/dist/esm/rechnung/summen.js

@@ -18,15 +18,9 @@
  * Dart-Zwilling pruefen gegen dieselbe Datei. Verbindlich bleibt, was der
  * Server rechnet — mit `previewInvoice` laesst sich das vorab abfragen.
  */
-/** Steuerfaelle, in denen die Rechnung keine Steuer ausweist: jede Zeile zaehlt zu 0 %. */
-export const STEUERFREIE_FAELLE = Object.freeze([
-    'smallBusiness',
-    'reverseCharge',
-    'igLieferung',
-    'exportThirdCountry',
-    'domesticReverseCharge',
-    'outsideScope',
-]);
+import { STEUERFREIE_FAELLE } from './rechnen.js';
+/** Aus dem Kern uebernommen, damit Kern und Huelle nie auseinanderlaufen. */
+export { 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;

package/dist/esm/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/esm/rechnung/vertrag.js

@@ -66,6 +66,8 @@ export const 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. */
 export const CREDIT_NOTE_REASONS = [

package/fixtures/hobex-hps-codes.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.22.0",
+  "version": "0.23.0",
   "gemessenAn": {
     "tid": "3600335",
     "hpsVersion": "1.10.0",

package/fixtures/kasse-texte.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.22.0",
+  "version": "0.23.0",
   "meldungen": {
     "netz.keine_verbindung": {
       "text": "Keine Verbindung zum Server. Bitte die Internetverbindung prüfen und erneut versuchen."

package/fixtures/oberflaeche.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.22.0",
+  "version": "0.23.0",
   "aufrufe": [
     "activateCashregister",
     "cancelInvoice",
@@ -410,7 +410,9 @@
       "reverse_charge_reason_required",
       "reverse_charge_threshold",
       "mixed_supply_not_allowed",
-      "oss_not_enabled"
+      "oss_not_enabled",
+      "einvoice_unavailable",
+      "amount_too_large"
     ],
     "invoiceLanguages": [
       "de",

package/fixtures/position-aus-euro.json

@@ -0,0 +1,107 @@
+{
+  "beschreibung": "Prüffälle des Umwandlers positionAusEuro (Euro-Position → Ganzzahl-Form). Preis in Millionstel Euro, Menge in Tausendstel, Rabatt und Satz in Hundertstel-Prozent. Umgewandelt wird über den kürzesten Dezimaltext der Zahl, nie per Gleitkomma-Multiplikation — Gleitkomma-Rauschen wie 0,30000000000000004 muss abgelehnt werden.",
+  "regel": "Fehlende Menge und fehlender Satz gelten als 0 (so rechnet der Server ab). Ein fehlender Preis ist nie 0, sondern ein Grund (kein_zahlwert). Ein Minus am Preis wandert an die Menge.",
+  "faelle": [
+    {
+      "name": "Ueblicher Fall: Preis, Menge, Satz und Rabatt zusammen",
+      "item": { "unitPrice": 9.9, "quantity": 3, "vatRate": 10, "discountPct": 5, "description": "Reinigung" },
+      "erwartet": {
+        "ok": true,
+        "position": { "unitPriceMicros": 9900000, "quantityMilli": 3000, "discountBp": 500, "vatRateBp": 1000, "description": "Reinigung" }
+      }
+    },
+    {
+      "name": "Schon Ganzzahl-Form kommt unveraendert zurueck",
+      "item": { "unitPriceMicros": 12345678, "quantityMilli": -500, "vatRateBp": 2000 },
+      "erwartet": {
+        "ok": true,
+        "position": { "unitPriceMicros": 12345678, "quantityMilli": -500, "vatRateBp": 2000 }
+      }
+    },
+    {
+      "name": "Fehlende Menge gilt als 0",
+      "item": { "unitPrice": 5.5, "vatRate": 10 },
+      "erwartet": {
+        "ok": true,
+        "position": { "unitPriceMicros": 5500000, "quantityMilli": 0, "discountBp": 0, "vatRateBp": 1000 }
+      }
+    },
+    {
+      "name": "Fehlender Satz gilt als 0",
+      "item": { "unitPrice": 3.33, "quantity": 4 },
+      "erwartet": {
+        "ok": true,
+        "position": { "unitPriceMicros": 3330000, "quantityMilli": 4000, "discountBp": 0, "vatRateBp": 0 }
+      }
+    },
+    {
+      "name": "Fehlender Preis ist nie 0",
+      "item": { "quantity": 2, "vatRate": 20 },
+      "erwartet": { "ok": false, "feld": "unitPrice", "grund": "kein_zahlwert" }
+    },
+    {
+      "name": "Negativer Preis wandert an die Menge",
+      "item": { "unitPrice": -7.5, "quantity": 3, "vatRate": 10 },
+      "erwartet": {
+        "ok": true,
+        "position": { "unitPriceMicros": 7500000, "quantityMilli": -3000, "discountBp": 0, "vatRateBp": 1000 }
+      }
+    },
+    {
+      "name": "Negative Menge bleibt negativ",
+      "item": { "unitPrice": 4, "quantity": -6 },
+      "erwartet": {
+        "ok": true,
+        "position": { "unitPriceMicros": 4000000, "quantityMilli": -6000, "discountBp": 0, "vatRateBp": 0 }
+      }
+    },
+    {
+      "name": "Gleitkomma-Rauschen am Preis (8,333333333333334) wird abgelehnt",
+      "item": { "unitPrice": 8.333333333333334 },
+      "erwartet": { "ok": false, "feld": "unitPrice", "grund": "nachkommastellen" }
+    },
+    {
+      "name": "Gleitkomma-Rauschen am Rabatt (0,30000000000000004) wird abgelehnt",
+      "item": { "unitPrice": 1, "quantity": 1, "discountPct": 0.30000000000000004 },
+      "erwartet": { "ok": false, "feld": "discountPct", "grund": "nachkommastellen" }
+    },
+    {
+      "name": "Menge mit 4 Nachkommastellen wird abgelehnt",
+      "item": { "unitPrice": 2, "quantity": 1.2345 },
+      "erwartet": { "ok": false, "feld": "quantity", "grund": "nachkommastellen" }
+    },
+    {
+      "name": "Rabatt 12,345 % wird abgelehnt",
+      "item": { "unitPrice": 1, "quantity": 1, "discountPct": 12.345 },
+      "erwartet": { "ok": false, "feld": "discountPct", "grund": "nachkommastellen" }
+    },
+    {
+      "name": "Text statt Zahl beim Preis",
+      "item": { "unitPrice": "9,99" },
+      "erwartet": { "ok": false, "feld": "unitPrice", "grund": "kein_zahlwert" }
+    },
+    {
+      "name": "Satz 120 % liegt ausserhalb",
+      "item": { "unitPrice": 1, "quantity": 1, "vatRate": 120 },
+      "erwartet": { "ok": false, "feld": "vatRate", "grund": "ausserhalb" }
+    },
+    {
+      "name": "Preis ueber 10^12 Mikro-Euro liegt ausserhalb",
+      "item": { "unitPrice": 1000001, "quantity": 1 },
+      "erwartet": { "ok": false, "feld": "unitPrice", "grund": "ausserhalb" }
+    },
+    {
+      "name": "Satz mit zwei Nachkommastellen (4,95 %) ist verlustfrei",
+      "item": { "unitPrice": 1, "quantity": 1, "vatRate": 4.95 },
+      "erwartet": {
+        "ok": true,
+        "position": { "unitPriceMicros": 1000000, "quantityMilli": 1000, "discountBp": 0, "vatRateBp": 495 }
+      }
+    },
+    {
+      "name": "Satz mit drei Nachkommastellen (4,955 %) wird abgelehnt",
+      "item": { "unitPrice": 1, "quantity": 1, "vatRate": 4.955 },
+      "erwartet": { "ok": false, "feld": "vatRate", "grund": "nachkommastellen" }
+    }
+  ]
+}

package/fixtures/rechnung-api.schema.json

@@ -2,7 +2,7 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "title": "Kasseneck Rechnungs-API",
   "version": 1,
-  "paket": "0.22.0",
+  "paket": "0.23.0",
   "aufrufe": {
     "createCustomer": {
       "anfrage": {
@@ -929,7 +929,9 @@
     "reverse_charge_reason_required",
     "reverse_charge_threshold",
     "mixed_supply_not_allowed",
-    "oss_not_enabled"
+    "oss_not_enabled",
+    "einvoice_unavailable",
+    "amount_too_large"
   ],
   "gruende": [
     "cancellation",