@kreiseck/kasseneck-api 0.6.7

package/dist/cjs/kasse/index.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPrintJob = exports.createPrintJob = exports.listMyPrinters = exports.receiptsScopeOf = exports.cancelScopeOf = exports.verteileRabatt = exports.setMyRegisterDeviceSettings = exports.setMyKasseSettings = exports.getKasseSettings = exports.mengeErlaubt = exports.mengenVorgabe = exports.mengenregelFuerEinheit = exports.listMyArticles = exports.listMyArticleGroups = exports.fromKasseArtikelPayload = exports.fromArticleGroupPayload = exports.mergeKasseSettings = exports.KASSE_GERAET_STANDARD = exports.KASSE_BETRIEB_STANDARD = exports.KASSE_TASTEN_STANDARD = exports.KASSE_TASTEN_AKTIONEN = exports.KARTENANBIETER = void 0;
+/**
+ * Kachel-Kasse: Einstellungen, Artikelgruppen/Artikel fuer Kacheln,
+ * Rabattverteilung. Die Aufrufe heissen 1:1 wie die Backend-Functions
+ * (die Rewrites-Waechter der Web-App leiten daraus ab).
+ */
+var settings_js_1 = require("./settings.js");
+Object.defineProperty(exports, "KARTENANBIETER", { enumerable: true, get: function () { return settings_js_1.KARTENANBIETER; } });
+Object.defineProperty(exports, "KASSE_TASTEN_AKTIONEN", { enumerable: true, get: function () { return settings_js_1.KASSE_TASTEN_AKTIONEN; } });
+Object.defineProperty(exports, "KASSE_TASTEN_STANDARD", { enumerable: true, get: function () { return settings_js_1.KASSE_TASTEN_STANDARD; } });
+Object.defineProperty(exports, "KASSE_BETRIEB_STANDARD", { enumerable: true, get: function () { return settings_js_1.KASSE_BETRIEB_STANDARD; } });
+Object.defineProperty(exports, "KASSE_GERAET_STANDARD", { enumerable: true, get: function () { return settings_js_1.KASSE_GERAET_STANDARD; } });
+Object.defineProperty(exports, "mergeKasseSettings", { enumerable: true, get: function () { return settings_js_1.mergeKasseSettings; } });
+var artikel_js_1 = require("./artikel.js");
+Object.defineProperty(exports, "fromArticleGroupPayload", { enumerable: true, get: function () { return artikel_js_1.fromArticleGroupPayload; } });
+Object.defineProperty(exports, "fromKasseArtikelPayload", { enumerable: true, get: function () { return artikel_js_1.fromKasseArtikelPayload; } });
+Object.defineProperty(exports, "listMyArticleGroups", { enumerable: true, get: function () { return artikel_js_1.listMyArticleGroups; } });
+Object.defineProperty(exports, "listMyArticles", { enumerable: true, get: function () { return artikel_js_1.listMyArticles; } });
+Object.defineProperty(exports, "mengenregelFuerEinheit", { enumerable: true, get: function () { return artikel_js_1.mengenregelFuerEinheit; } });
+Object.defineProperty(exports, "mengenVorgabe", { enumerable: true, get: function () { return artikel_js_1.mengenVorgabe; } });
+Object.defineProperty(exports, "mengeErlaubt", { enumerable: true, get: function () { return artikel_js_1.mengeErlaubt; } });
+var client_js_1 = require("./client.js");
+Object.defineProperty(exports, "getKasseSettings", { enumerable: true, get: function () { return client_js_1.getKasseSettings; } });
+Object.defineProperty(exports, "setMyKasseSettings", { enumerable: true, get: function () { return client_js_1.setMyKasseSettings; } });
+Object.defineProperty(exports, "setMyRegisterDeviceSettings", { enumerable: true, get: function () { return client_js_1.setMyRegisterDeviceSettings; } });
+var discount_js_1 = require("../receipt/discount.js");
+Object.defineProperty(exports, "verteileRabatt", { enumerable: true, get: function () { return discount_js_1.verteileRabatt; } });
+// Reichweiten der Kassen-Rechte (Migration wie im Backend) -- bewusst NICHT im
+// Register-Unterpfad: dessen Exportnamen sind 1:1 Function-Namen (Rewrites).
+var pairing_js_1 = require("../register/pairing.js");
+Object.defineProperty(exports, "cancelScopeOf", { enumerable: true, get: function () { return pairing_js_1.cancelScopeOf; } });
+Object.defineProperty(exports, "receiptsScopeOf", { enumerable: true, get: function () { return pairing_js_1.receiptsScopeOf; } });
+var drucker_js_1 = require("./drucker.js");
+Object.defineProperty(exports, "listMyPrinters", { enumerable: true, get: function () { return drucker_js_1.listMyPrinters; } });
+Object.defineProperty(exports, "createPrintJob", { enumerable: true, get: function () { return drucker_js_1.createPrintJob; } });
+Object.defineProperty(exports, "getPrintJob", { enumerable: true, get: function () { return drucker_js_1.getPrintJob; } });

package/dist/cjs/kasse/settings.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Kassen-Einstellungen der Browser-Kasse — Zwilling von
+ * `functions/kasse-settings-core.js` (Backend, dort mit Validator).
+ *
+ * Betriebsweit (`register_settings.kasse` am Konto) und je Geraet
+ * (`register_devices/{id}.kasse`). Die Standardwerte stehen hier UND im
+ * Backend; ein Test in beiden Repos haelt sie deckungsgleich. Trinkgeld ist
+ * bewusst AUS, bis die Buchung geklaert ist (Spec kachel-kasse § 9).
+ */
+export type KasseStil = 'klar' | 'warm' | 'nacht' | 'kontrast';
+export type KasseSchrift = 'S' | 'M' | 'L' | 'XL';
+export type KasseWasserzeichen = 'aus' | 'anmeldung' | 'ueberall';
+export type KasseMenge = 'aus' | 'x' | 'kg';
+export type KasseTgModus = 'betrag' | 'gesamt' | 'beides';
+export type KasseKassierenModus = 'seite' | 'panel';
+/** Kartenanbieter: Karte gibt es erst mit eingerichtetem Anbieter; 'extern' = eigenes Terminal ohne Anbindung. */
+export type KasseKartenanbieter = 'keiner' | 'extern' | 'hobex' | 'mypos' | 'stripe';
+export declare const KARTENANBIETER: readonly KasseKartenanbieter[];
+export type KasseBelegAusgabe = 'qr' | 'druck' | 'mail' | 'sms' | 'fragen';
+export type KasseLayout = 'rechts' | 'links' | 'vollbild';
+export type KasseKatpos = 'oben' | 'links';
+export type KasseHoehe = 'S' | 'M' | 'L';
+/** `sdp` = Netzwerk ueber Epson Server Direct Print (der Drucker holt Jobs vom Backend, jeder Browser druckt). */
+export type KasseDruckerArt = 'sdp' | 'netz' | 'bt' | 'usb';
+export type KassePapier = 'mm58' | 'mm80';
+export type KasseZeichensatz = 'CP1252' | 'CP437';
+export type KasseSchnitt = 'partial' | 'full' | 'none';
+export type KasseLadeAuto = 'bar' | 'immer' | 'nie';
+/** Schalter-Landkarte: Steuersaetze / Trinkgeldstufen (Schluessel = Wert als Text). */
+export type Schalterkarte = Record<string, boolean>;
+export interface KasseSettingsBetrieb {
+    logoText: string;
+    logoAn: boolean;
+    logoGroesse: 'S' | 'M' | 'L';
+    wasserzeichen: KasseWasserzeichen;
+    farbe: string;
+    stil: KasseStil;
+    schrift: KasseSchrift;
+    schriftEinst: 'S' | 'M' | 'L';
+    kachelstil: 'streifen' | 'voll';
+    uhr: boolean;
+    sperrbild: boolean;
+    foto: boolean;
+    autoAbMin: 0 | 1 | 5 | 15 | 30;
+    abNachVerkauf: boolean;
+    /** Schnelles Entsperren mit gemerkter PIN (lokal, Server-Login laeuft nach); aus = streng, jeder Login wartet. */
+    schnellLogin: boolean;
+    preisAnzeigen: boolean;
+    ustAnzeigen: boolean;
+    emoji: boolean;
+    katFarben: boolean;
+    freiErlaubt: boolean;
+    saetze: Schalterkarte;
+    menge: KasseMenge;
+    notiz: boolean;
+    suche: boolean;
+    rabatt: 'aus' | 'an';
+    zahlBar: boolean;
+    zahlKarte: boolean;
+    kartenanbieter: KasseKartenanbieter;
+    trinkgeld: boolean;
+    tgModus: KasseTgModus;
+    tgStufen: Schalterkarte;
+    tgSplit: boolean;
+    rueckgeld: boolean;
+    schnellbar: boolean;
+    kassierenModus: KasseKassierenModus;
+    /** Trinkgeld-Chips in Prozent (eine Nachkommastelle, max 5, eindeutig, Reihenfolge des Chefs). */
+    tgChips: number[];
+    belegAusgabe: KasseBelegAusgabe;
+    fertigSekunden: 0 | 3 | 5 | 10 | 15 | 30 | 60;
+}
+/** Aktionen der Kasse, die eine Taste bekommen koennen. */
+export type KasseTastenAktion = 'kassieren' | 'abschliessen' | 'abbrechen' | 'frei' | 'bar' | 'karte' | 'passend' | 'belege' | 'letzteZurueck';
+export declare const KASSE_TASTEN_AKTIONEN: readonly KasseTastenAktion[];
+/** Tastenkarte: Aktion -> Tasten (`Mod+F`, `Enter`, `Escape`, `F5` ...; `Mod` = ⌘ auf dem Mac, Strg sonst). */
+export type KasseTastenkarte = Record<KasseTastenAktion, string[]>;
+export declare const KASSE_TASTEN_STANDARD: Readonly<KasseTastenkarte>;
+export interface KasseSettingsGeraet {
+    layout: KasseLayout;
+    katpos: KasseKatpos;
+    spaltenExtra: number;
+    hoehe: KasseHoehe;
+    touch: boolean;
+    /** Tastenbelegung dieses Geraets (Vorgabe KASSE_TASTEN_STANDARD, je Aktion mischbar). */
+    tasten: KasseTastenkarte;
+    druckerAn: boolean;
+    druckerArt: KasseDruckerArt;
+    druckerIp: string;
+    druckerPort: number;
+    druckerBt: string;
+    /** Kennung des Netzwerk-Druckers (Server Direct Print) aus `listMyPrinters`; '' = keiner gewaehlt. */
+    druckerId: string;
+    /** ePOS Device-ID bei `druckerArt 'netz'` (Epson direkt per IP), Vorgabe `local_printer`. */
+    druckerDevid: string;
+    papier: KassePapier;
+    zeichensatz: KasseZeichensatz;
+    schnitt: KasseSchnitt;
+    ladeAn: boolean;
+    ladeAuto: KasseLadeAuto;
+    terminalIp: string;
+    terminalPort: number;
+}
+export interface KasseSettings {
+    betrieb: KasseSettingsBetrieb;
+    geraet: KasseSettingsGeraet;
+}
+export declare const KASSE_BETRIEB_STANDARD: Readonly<KasseSettingsBetrieb>;
+export declare const KASSE_GERAET_STANDARD: Readonly<KasseSettingsGeraet>;
+/**
+ * Standard + gespeichert. Landkarten (`saetze`, `tgStufen`) werden je Schluessel
+ * gemischt, damit neue Saetze beim Altbestand ankommen; unbekannte Schluessel
+ * bleiben draussen (die Wahrheit ueber Gueltigkeit hat der Server).
+ */
+export declare function mergeKasseSettings<T extends object>(standard: Readonly<T>, gespeichert: Partial<T> | null | undefined): T;

package/dist/cjs/kasse/settings.js

@@ -0,0 +1,62 @@
+"use strict";
+/**
+ * Kassen-Einstellungen der Browser-Kasse — Zwilling von
+ * `functions/kasse-settings-core.js` (Backend, dort mit Validator).
+ *
+ * Betriebsweit (`register_settings.kasse` am Konto) und je Geraet
+ * (`register_devices/{id}.kasse`). Die Standardwerte stehen hier UND im
+ * Backend; ein Test in beiden Repos haelt sie deckungsgleich. Trinkgeld ist
+ * bewusst AUS, bis die Buchung geklaert ist (Spec kachel-kasse § 9).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KASSE_GERAET_STANDARD = exports.KASSE_BETRIEB_STANDARD = exports.KASSE_TASTEN_STANDARD = exports.KASSE_TASTEN_AKTIONEN = exports.KARTENANBIETER = void 0;
+exports.mergeKasseSettings = mergeKasseSettings;
+exports.KARTENANBIETER = ['keiner', 'extern', 'hobex', 'mypos', 'stripe'];
+exports.KASSE_TASTEN_AKTIONEN = ['kassieren', 'abschliessen', 'abbrechen', 'frei', 'bar', 'karte', 'passend', 'belege', 'letzteZurueck'];
+exports.KASSE_TASTEN_STANDARD = Object.freeze({
+    kassieren: ['Enter'], abschliessen: ['Enter'], abbrechen: ['Escape'],
+    frei: ['Mod+F'], bar: ['Mod+B'], karte: ['Mod+K'], passend: ['Mod+P'],
+    belege: ['Mod+E'], letzteZurueck: ['Mod+Backspace'],
+});
+exports.KASSE_BETRIEB_STANDARD = Object.freeze({
+    logoText: 'K', logoAn: true, logoGroesse: 'M', wasserzeichen: 'anmeldung', farbe: '#1B46F5',
+    stil: 'klar', schrift: 'M', schriftEinst: 'S', kachelstil: 'streifen', uhr: true,
+    sperrbild: true, foto: true, autoAbMin: 0, abNachVerkauf: false, schnellLogin: true,
+    preisAnzeigen: true, ustAnzeigen: false, emoji: true, katFarben: true, freiErlaubt: true,
+    saetze: { 20: true, 13: true, 10: true, 4.9: true, 0: true, 19: false },
+    menge: 'x', notiz: false, suche: false, rabatt: 'aus',
+    zahlBar: true, zahlKarte: false, kartenanbieter: 'keiner', trinkgeld: false, tgModus: 'beides',
+    tgStufen: { 5: true, 10: true, 15: false, 20: false }, tgChips: [5, 10], tgSplit: true, rueckgeld: true,
+    schnellbar: false, kassierenModus: 'seite',
+    belegAusgabe: 'qr', fertigSekunden: 0,
+});
+exports.KASSE_GERAET_STANDARD = Object.freeze({
+    layout: 'rechts', katpos: 'oben', spaltenExtra: 0, hoehe: 'M', touch: false,
+    tasten: { ...exports.KASSE_TASTEN_STANDARD },
+    druckerAn: false, druckerArt: 'sdp', druckerIp: '', druckerPort: 9100, druckerBt: '', druckerId: '', druckerDevid: 'local_printer',
+    papier: 'mm80', zeichensatz: 'CP1252', schnitt: 'partial',
+    ladeAn: false, ladeAuto: 'bar',
+    terminalIp: '', terminalPort: 20008,
+});
+/**
+ * Standard + gespeichert. Landkarten (`saetze`, `tgStufen`) werden je Schluessel
+ * gemischt, damit neue Saetze beim Altbestand ankommen; unbekannte Schluessel
+ * bleiben draussen (die Wahrheit ueber Gueltigkeit hat der Server).
+ */
+function mergeKasseSettings(standard, gespeichert) {
+    const out = JSON.parse(JSON.stringify(standard));
+    if (gespeichert && typeof gespeichert === 'object') {
+        for (const [key, wert] of Object.entries(gespeichert)) {
+            if (!(key in out))
+                continue;
+            const alt = out[key];
+            if (alt && typeof alt === 'object' && !Array.isArray(alt) && wert && typeof wert === 'object' && !Array.isArray(wert)) {
+                out[key] = { ...alt, ...wert };
+            }
+            else if (wert !== undefined) {
+                out[key] = wert;
+            }
+        }
+    }
+    return out;
+}

package/dist/cjs/models/cancellation.d.ts

@@ -0,0 +1,51 @@
+import type { Receipt } from './receipt.js';
+/**
+ * Storno-Metadaten — Zwilling von `functions/storno-core.js`.
+ *
+ * Ein Storno ist ein eigener, signierter Beleg vom Typ `cancellation` mit
+ * negativen Betraegen. Was NICHT signiert ist und hier als Metadaten laeuft:
+ * der Bezug zum Original (`cancellationOf`, `cancellationReason` am
+ * Storno-Beleg) und die Liste der Stornos am Original (`cancellations`), aus
+ * der sich die Restmengen ergeben.
+ */
+/** Grund-Katalog: Codes wie im Backend, Anzeigetext fuer Bon und Bedienung. */
+export declare const CANCELLATION_REASONS: Readonly<{
+    readonly fehleingabe: "Fehleingabe";
+    readonly kunde_storniert: "Kunde hat storniert";
+    readonly falsche_zahlart: "Falsche Zahlart";
+    readonly doppelt_erfasst: "Doppelt erfasst";
+    readonly sonstiges: "Sonstiges";
+}>;
+export type CancellationReason = keyof typeof CANCELLATION_REASONS;
+export declare function isCancellationReason(value: unknown): value is CancellationReason;
+/** Bezug eines Storno-Belegs auf sein Original. */
+export interface CancellationOf {
+    receiptId: string;
+    fullReceiptId: string | null;
+}
+/** Eine stornierte Position: Index im Original und Menge. */
+export interface CancellationItem {
+    index: number;
+    quantity: number;
+}
+/**
+ * Eintrag in `cancellations[]` am Original. `pending` = Reservierung, die
+ * das Backend vor der Buchung setzt und danach ersetzt; sie zaehlt fuer die
+ * Restmengen nur, solange sie frisch ist (siehe [remainingQuantities]).
+ */
+export interface Cancellation {
+    receiptId?: string;
+    pending?: boolean;
+    at: number;
+    by: string | null;
+    note: string | null;
+    items: CancellationItem[];
+}
+/** Ab wann eine liegengebliebene Reservierung nicht mehr zaehlt (wie im Backend). */
+export declare const CANCELLATION_RESERVATION_MS = 120000;
+/**
+ * Restmenge je Position eines Belegs — Belegmenge minus alles, was storniert
+ * oder frisch reserviert ist; nie unter null. Fuer den Storno-Dialog der Kasse
+ * (Reste anzeigen, bevor der Server gefragt wird). Die Wahrheit hat der Server.
+ */
+export declare function remainingQuantities(receipt: Receipt, nowMs?: number): number[];

package/dist/cjs/models/cancellation.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CANCELLATION_RESERVATION_MS = exports.CANCELLATION_REASONS = void 0;
+exports.isCancellationReason = isCancellationReason;
+exports.remainingQuantities = remainingQuantities;
+/**
+ * Storno-Metadaten — Zwilling von `functions/storno-core.js`.
+ *
+ * Ein Storno ist ein eigener, signierter Beleg vom Typ `cancellation` mit
+ * negativen Betraegen. Was NICHT signiert ist und hier als Metadaten laeuft:
+ * der Bezug zum Original (`cancellationOf`, `cancellationReason` am
+ * Storno-Beleg) und die Liste der Stornos am Original (`cancellations`), aus
+ * der sich die Restmengen ergeben.
+ */
+/** Grund-Katalog: Codes wie im Backend, Anzeigetext fuer Bon und Bedienung. */
+exports.CANCELLATION_REASONS = Object.freeze({
+    fehleingabe: 'Fehleingabe',
+    kunde_storniert: 'Kunde hat storniert',
+    falsche_zahlart: 'Falsche Zahlart',
+    doppelt_erfasst: 'Doppelt erfasst',
+    sonstiges: 'Sonstiges',
+});
+function isCancellationReason(value) {
+    return typeof value === 'string' && Object.prototype.hasOwnProperty.call(exports.CANCELLATION_REASONS, value);
+}
+/** Ab wann eine liegengebliebene Reservierung nicht mehr zaehlt (wie im Backend). */
+exports.CANCELLATION_RESERVATION_MS = 120_000;
+/**
+ * Restmenge je Position eines Belegs — Belegmenge minus alles, was storniert
+ * oder frisch reserviert ist; nie unter null. Fuer den Storno-Dialog der Kasse
+ * (Reste anzeigen, bevor der Server gefragt wird). Die Wahrheit hat der Server.
+ */
+function remainingQuantities(receipt, nowMs = Date.now()) {
+    const rest = receipt.items.map((item) => item.quantity);
+    for (const eintrag of receipt.cancellations ?? []) {
+        if (eintrag.pending === true && eintrag.at < nowMs - exports.CANCELLATION_RESERVATION_MS)
+            continue;
+        for (const pos of eintrag.items) {
+            if (Number.isInteger(pos.index) && pos.index >= 0 && pos.index < rest.length) {
+                rest[pos.index] = Math.max(0, (rest[pos.index] ?? 0) - pos.quantity);
+            }
+        }
+    }
+    return rest;
+}

package/dist/cjs/models/cashregister.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Kasse — die Antwortform von `listMyCashregisters` (functions/index.js).
+ *
+ * Das Dart-Vorbild (`Cashregister` in kasseneck_api/lib/models/cashregister.dart)
+ * liest das **Firestore-Dokument** direkt ueber das `cloud_firestore`-SDK und
+ * kommt deshalb an `token` und `aes_key`. Dieses Paket spricht das Backend
+ * ausschliesslich ueber die HTTPS-Endpunkte, und die geben beides nicht her:
+ *
+ * - **`aes_key` steht in dieser Antwort ueberhaupt nicht** (nur im
+ *   Admin-Export). Ein Feld dafuer versprach hier einen `string` und lieferte
+ *   `undefined` — deshalb gibt es keines mehr.
+ * - **`token` ist fuer Kassen-Benutzer bewusst `null`**: im Browser traegt die
+ *   Sitzung die Identitaet, und ein einmal ausgelieferter Kassen-Token liesse
+ *   sich ohne Sitzung und ohne PIN weiterverwenden (so steht es im Backend an
+ *   der Stelle selbst).
+ *
+ * `create_time` kommt aus `isoTs(...)` und ist **`null`**, wenn das Dokument
+ * keinen Zeitstempel traegt. Aus `null` wird hier kein Zeitpunkt: `new Date(null)`
+ * ergaebe still den 1.1.1970, und ein erfundenes Datum ist schlechter als ein
+ * fehlendes.
+ *
+ * Aus demselben Grund fehlt `userId`: das Dart-Vorbild traegt es, weil es den
+ * Firestore-**Pfad** kennt (`users/{uid}/cashregisters/{id}`). In dieser
+ * Antwort steht es nicht, und ein Kassen-Benutzer erfaehrt die Kennung seines
+ * Betriebs bewusst nie — sie steckt allein im Token.
+ */
+export interface Cashregister {
+    id: string;
+    /** Anzeigename der Kasse, sofern gepflegt. */
+    label?: string;
+    /** Freie Beschreibung, sofern gepflegt. */
+    description?: string;
+    /** Anlagezeitpunkt; fehlt, wenn die Antwort keinen lesbaren traegt. */
+    createTime?: Date;
+    /** Kassen-Token; fuer Kassen-Benutzer nie enthalten (siehe Klassenkommentar). */
+    token?: string;
+    /** Zugeordnete Signatureinheit. */
+    signatureId?: string;
+    onboarding: CashregisterOnboarding;
+}
+/**
+ * Stand der Inbetriebnahme (RKSV): Kasse bei FinanzOnline registriert,
+ * Startbeleg erzeugt, Startbeleg uebermittelt. Die drei Kennzeichen entscheiden
+ * in der Browser-Kasse, ob ueberhaupt schon kassiert werden darf.
+ */
+export interface CashregisterOnboarding {
+    cashboxRegistered: boolean;
+    startbelegCreated: boolean;
+    startbelegTransmitted: boolean;
+    cashboxRegisteredAt?: Date;
+    startbelegCreatedAt?: Date;
+    startbelegTransmittedAt?: Date;
+}
+/** Nutzlast-Form, die dieses Paket liest — die Feldnamen von `listMyCashregisters`. */
+export interface CashregisterPayload {
+    id?: string | null;
+    label?: string | null;
+    description?: string | null;
+    create_time?: string | null;
+    signature_id?: string | null;
+    token?: string | null;
+    onboarding?: CashregisterOnboardingPayload | null;
+}
+export interface CashregisterOnboardingPayload {
+    cashbox_registered?: boolean | null;
+    startbeleg_created?: boolean | null;
+    startbeleg_transmitted?: boolean | null;
+    cashbox_registered_at?: string | null;
+    startbeleg_created_at?: string | null;
+    startbeleg_transmitted_at?: string | null;
+}
+/**
+ * Liest eine Kasse aus der Antwort. `id` gewinnt aus der Nutzlast, faellt aber
+ * auf den uebergebenen Wert zurueck — die Liste fuehrt die Dokument-ID mit,
+ * ein einzeln gelesenes Dokument nicht.
+ */
+export declare function fromCashregisterPayload(payload: CashregisterPayload, id: string): Cashregister;

package/dist/cjs/models/cashregister.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromCashregisterPayload = fromCashregisterPayload;
+const vienna_time_js_1 = require("../vienna-time.js");
+/**
+ * Liest eine Kasse aus der Antwort. `id` gewinnt aus der Nutzlast, faellt aber
+ * auf den uebergebenen Wert zurueck — die Liste fuehrt die Dokument-ID mit,
+ * ein einzeln gelesenes Dokument nicht.
+ */
+function fromCashregisterPayload(payload, id) {
+    const ob = payload.onboarding ?? {};
+    return {
+        id: payload.id ?? id,
+        ...(payload.label ? { label: payload.label } : {}),
+        ...(payload.description ? { description: payload.description } : {}),
+        ...zeitfeld('createTime', payload.create_time),
+        ...(payload.token ? { token: payload.token } : {}),
+        ...(payload.signature_id ? { signatureId: payload.signature_id } : {}),
+        onboarding: {
+            cashboxRegistered: ob.cashbox_registered === true,
+            startbelegCreated: ob.startbeleg_created === true,
+            startbelegTransmitted: ob.startbeleg_transmitted === true,
+            ...zeitfeld('cashboxRegisteredAt', ob.cashbox_registered_at),
+            ...zeitfeld('startbelegCreatedAt', ob.startbeleg_created_at),
+            ...zeitfeld('startbelegTransmittedAt', ob.startbeleg_transmitted_at),
+        },
+    };
+}
+/**
+ * Ein Zeitfeld, das es nur gibt, wenn die Nutzlast einen lesbaren Zeitstempel
+ * traegt. `null` (der Normalfall aus `isoTs`) und unlesbarer Unsinn ergeben
+ * **kein** Feld statt eines erfundenen Zeitpunkts — die Kassenliste soll sich
+ * auch dann anzeigen lassen, wenn ein einzelner Eintrag ein kaputtes Datum
+ * fuehrt (dieselbe tolerante Leserichtung wie beim Enum-Lesen).
+ */
+function zeitfeld(name, roh) {
+    const wert = zeitpunkt(roh);
+    return (wert === undefined ? {} : { [name]: wert });
+}
+function zeitpunkt(roh) {
+    if (typeof roh !== 'string' || roh.trim() === '') {
+        return undefined;
+    }
+    try {
+        // Ueber parseServerTimeStamp und nie ueber `new Date(text)`: ein
+        // offsetloser Zeitstempel waere sonst die lokale Zeit des ausfuehrenden
+        // Rechners (siehe ../vienna-time.ts).
+        return (0, vienna_time_js_1.parseServerTimeStamp)(roh);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/cjs/models/enum-payload.d.ts

@@ -0,0 +1,26 @@
+import { VatRate } from '../enums/index.js';
+/**
+ * Loest einen Enum-Eintrag anhand seines Nutzlast-Schluessels auf (z. B.
+ * `receiptType: 'standard'` — bei den mit `defineEnum()` gebauten Enums ist
+ * der Objekt-Schluessel selbst die Nutzlast).
+ *
+ * Nur fuer den **Schreibpfad**: bevor dieses Paket selbst einen Wert nach
+ * aussen traegt, muss er bekannt sein — ein unbekannter Schluessel wirft.
+ * Fuer den Lesepfad (Daten, die vom Backend hereinkommen) siehe
+ * [readEnumKey]: dort darf ein einzelner unbekannter Wert nicht die ganze
+ * Belegliste zum Absturz bringen.
+ */
+export declare function requireEnumKey<T extends Record<string, unknown>>(enumObj: T, key: string, label: string): T[keyof T];
+/**
+ * Lesepfad-Pendant zu [requireEnumKey]: ein unbekannter Schluessel (z. B. ein
+ * neuer Belegtyp oder eine neue Zahlungsart, die dieses Paket noch nicht
+ * kennt) wirft nicht und wird auch nicht still zu `undefined` — der rohe
+ * Nutzlast-Schluessel bleibt als String erhalten. Ein Aufrufer, der eine
+ * Belegliste anzeigt, kann so alle Positionen weiterlesen; nur die unbekannte
+ * bleibt (erkennbar) unaufgeloest.
+ */
+export declare function readEnumKey<T extends Record<string, unknown>>(enumObj: T, key: string): T[keyof T] | string;
+/** Schreibpfad: loest einen Steuersatz anhand seines `rate`-Werts auf, wirft bei unbekanntem Satz. */
+export declare function requireVatRateByRate(rate: number): VatRate;
+/** Lesepfad: unbekannter Satz bleibt als roher `rate`-Wert erhalten statt zu werfen oder `undefined` zu werden. */
+export declare function readVatRateByRate(rate: number): VatRate | number;

package/dist/cjs/models/enum-payload.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireEnumKey = requireEnumKey;
+exports.readEnumKey = readEnumKey;
+exports.requireVatRateByRate = requireVatRateByRate;
+exports.readVatRateByRate = readVatRateByRate;
+const index_js_1 = require("../enums/index.js");
+/**
+ * Loest einen Enum-Eintrag anhand seines Nutzlast-Schluessels auf (z. B.
+ * `receiptType: 'standard'` — bei den mit `defineEnum()` gebauten Enums ist
+ * der Objekt-Schluessel selbst die Nutzlast).
+ *
+ * Nur fuer den **Schreibpfad**: bevor dieses Paket selbst einen Wert nach
+ * aussen traegt, muss er bekannt sein — ein unbekannter Schluessel wirft.
+ * Fuer den Lesepfad (Daten, die vom Backend hereinkommen) siehe
+ * [readEnumKey]: dort darf ein einzelner unbekannter Wert nicht die ganze
+ * Belegliste zum Absturz bringen.
+ */
+function requireEnumKey(enumObj, key, label) {
+    if (!Object.prototype.hasOwnProperty.call(enumObj, key)) {
+        throw new Error(`${label}: unbekannter Schluessel "${key}" in der Nutzlast`);
+    }
+    return enumObj[key];
+}
+/**
+ * Lesepfad-Pendant zu [requireEnumKey]: ein unbekannter Schluessel (z. B. ein
+ * neuer Belegtyp oder eine neue Zahlungsart, die dieses Paket noch nicht
+ * kennt) wirft nicht und wird auch nicht still zu `undefined` — der rohe
+ * Nutzlast-Schluessel bleibt als String erhalten. Ein Aufrufer, der eine
+ * Belegliste anzeigt, kann so alle Positionen weiterlesen; nur die unbekannte
+ * bleibt (erkennbar) unaufgeloest.
+ */
+function readEnumKey(enumObj, key) {
+    return Object.prototype.hasOwnProperty.call(enumObj, key) ? enumObj[key] : key;
+}
+function findVatRate(rate) {
+    return Object.values(index_js_1.VatRate).find((v) => v.rate === rate);
+}
+/** Schreibpfad: loest einen Steuersatz anhand seines `rate`-Werts auf, wirft bei unbekanntem Satz. */
+function requireVatRateByRate(rate) {
+    const eintrag = findVatRate(rate);
+    if (!eintrag) {
+        throw new Error(`Steuersatz: unbekannter Satz "${rate}" in der Nutzlast`);
+    }
+    return eintrag;
+}
+/** Lesepfad: unbekannter Satz bleibt als roher `rate`-Wert erhalten statt zu werfen oder `undefined` zu werden. */
+function readVatRateByRate(rate) {
+    return findVatRate(rate) ?? rate;
+}

package/dist/cjs/models/hobex-receipt.d.ts

@@ -0,0 +1,63 @@
+import { CreditCardProvider } from '../enums/index.js';
+/**
+ * Hobex-Kartenzahlungsbeleg — Zwilling von `HobexReceipt` in
+ * kasseneck_api/lib/models/hobex_receipt.dart.
+ *
+ * `amount`/`tip` kommen vom Hobex-Terminal als Euro-Gleitkommazahl ueber die
+ * Leitung (Terminal-API, nicht das Kasseneck-Backend) — das Nutzlast-Format
+ * bleibt deshalb bewusst Euro (siehe [toHobexReceiptPayload]/
+ * [fromHobexReceiptPayload]), intern wird ab hier exakt in Cent gefuehrt.
+ *
+ * Nur der Cloud-API-Pfad (`fromJson` im Dart-Vorbild) ist Teil dieses Pakets;
+ * das lokale HPS-Terminal (`fromHps`, TCP-Anbindung an ein physisches Geraet)
+ * ist wie SumUp/myPOS eine Android/Desktop-Geraete-Anbindung, die ein
+ * Browser-/Node-Paket nicht bedienen kann.
+ */
+export interface HobexReceipt {
+    transactionId: string;
+    tid: string;
+    receipt: string;
+    approvalCode: string;
+    reference?: string;
+    /** Normalisiert wie im Dart-Vorbild: `"YYYY-MM-DD HH:mm:ss"` (Bruchteil und `T` entfernt). */
+    transactionDate: string;
+    cardNumber: string;
+    cardExpiry: string;
+    brand: string;
+    cardIssuer: string;
+    responseCode: string;
+    transactionType: string;
+    currency: string;
+    amountCents: number;
+    tipCents: number;
+    cvm: string;
+    creditCardProvider: CreditCardProvider;
+}
+export interface HobexReceiptPayload {
+    transactionId: string;
+    tid: string;
+    receipt: string;
+    approvalCode: string;
+    reference: string | null | undefined;
+    transactionDate: string;
+    cardNumber: string;
+    cardExpiry: string;
+    brand: string;
+    cardIssuer: string;
+    responseCode: string;
+    transactionType: string;
+    currency: string;
+    amount: number;
+    tip: number;
+    cvm: string | number;
+}
+export declare function toHobexReceiptPayload(beleg: HobexReceipt): HobexReceiptPayload;
+export declare function fromHobexReceiptPayload(payload: HobexReceiptPayload): HobexReceipt;
+/**
+ * Wandelt den Beleg in die `cardPaymentData`-Map, die auf dem Kasseneck-Beleg
+ * landet (siehe [Receipt.cardPaymentData]). Bei HPS-Zahlungen kommen weitere
+ * Felder dazu, die nur das lokale Terminal liefert.
+ */
+export declare function hobexReceiptToCardPaymentData(beleg: HobexReceipt): Record<string, string>;
+/** Kartenzahlung erfordert eine Unterschrift (CVM-Code `"1"`). */
+export declare function hobexReceiptNeedsSignature(beleg: HobexReceipt): boolean;