@kreiseck/kasseneck-api 0.6.7

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

@@ -0,0 +1,108 @@
+import { ReceiptType, KeckPaymentMethod, CreditCardProvider } from '../enums/index.js';
+import { type ReceiptItem, type ReceiptItemPayload, type ReceiptItemPayloadRead } from './receipt-item.js';
+import { type Voucher, type VoucherPayload } from './voucher.js';
+import type { Cancellation, CancellationOf, CancellationReason } from './cancellation.js';
+import { type ZeroKind } from './receipt-summary.js';
+/**
+ * Beleg — Zwilling der Beleg-Nutzlast von `KasseneckReceipt` in
+ * kasseneck_api/lib/models/kasseneck_receipt.dart (nur der signatur-/
+ * positionsrelevante Teil, den `toReceiptJson()`/die `receipt`-Map von
+ * `fromJson()` traegt — nicht die Firmen-/Druckdaten wie Firma, Adresse oder
+ * Fusszeilen: die betreffen ausschliesslich das Beleg-Rendering und gehoeren
+ * nicht zum RKSV-Kernbeleg. Sie stehen als eigenes Modell daneben, siehe
+ * `ReceiptCompany` in ./receipt-company.ts).
+ *
+ * `timeStamp` bleibt bewusst der rohe Zeitstempel-String aus der Nutzlast;
+ * `parseServerTimeStamp` (`../vienna-time.js`) deutet ihn auf Wunsch in einen
+ * echten Zeitpunkt um (uneinheitliches Server-Format, siehe dort).
+ *
+ * `paymentMethod`/`receiptType`/`creditCardProvider` sind beim Lesen entweder
+ * der bekannte Enum-Eintrag oder — bei einem der Nutzlast unbekannten
+ * Schluessel — der rohe String (siehe `enum-payload.ts`, `readEnumKey`).
+ */
+export interface Receipt {
+    receiptId: string;
+    cashregisterId: string;
+    timeStamp: string;
+    items: ReceiptItem[];
+    vouchers: Voucher[];
+    paymentMethod: KeckPaymentMethod | string;
+    turnoverCounterAES256ICM: string;
+    signaturePreviousReceipt: string;
+    certificateSerialNumber: string;
+    receiptType: ReceiptType | string;
+    sig: string;
+    qr: string;
+    fullReceiptId: string;
+    creditCardProvider?: CreditCardProvider | string;
+    cardPaymentId?: string;
+    cardPaymentData?: Record<string, unknown>;
+    customerDetails: string[];
+    legalMessage: string[];
+    signatureSuccess?: boolean;
+    customProjectId?: string;
+    /** Nur am Storno-Beleg: das stornierte Original. */
+    cancellationOf?: CancellationOf;
+    /** Nur am Storno-Beleg: Grund-Code aus [CANCELLATION_REASONS]. */
+    cancellationReason?: CancellationReason | string;
+    /** Nur am Original: alle (Teil-)Stornos, Quelle der Restmengen. */
+    cancellations?: Cancellation[];
+    /** Nur an Nullbelegen: Anlass (monthly, annual, annual_replacement, outage_end, final, manual). */
+    zeroKind?: ZeroKind;
+}
+export interface ReceiptPayload {
+    qr: string;
+    sig: string;
+    certificateSerialNumber: string;
+    signaturePreviousReceipt: string;
+    turnoverCounterAES256ICM: string;
+    paymentMethod: string;
+    items: ReceiptItemPayload[];
+    vouchers: VoucherPayload[] | null;
+    timeStamp: string;
+    cashregisterId: string;
+    receiptType: string;
+    receiptId: string;
+    fullReceiptId: string;
+    creditCardProvider: string | null;
+    cardPaymentId: string | null;
+    cardPaymentData: Record<string, unknown> | null;
+    customerDetails: string;
+    legalMessage: string;
+    signatureSuccess: boolean | null;
+    customProjectId: string | null;
+}
+/**
+ * Nutzlast-Form, die dieses Paket **liest**. Unterscheidet sich von
+ * [ReceiptPayload] bei den Positionen: ein gespeicherter Beleg traegt sie in
+ * der v1-Form, die das Backend ablegt (siehe [ReceiptItemPayloadRead]).
+ * Nullbelege haben ueberhaupt keine Positionen.
+ */
+export interface ReceiptPayloadRead extends Omit<ReceiptPayload, 'items' | 'vouchers'> {
+    items?: ReceiptItemPayloadRead[] | null;
+    vouchers?: VoucherPayload[] | null;
+    cancellationOf?: CancellationOf | null;
+    cancellationReason?: string | null;
+    zeroKind?: string | null;
+    cancellations?: Cancellation[] | null;
+}
+/**
+ * Schreibt die Nutzlast in der **neuen** Form — sie **normalisiert, statt zu
+ * spiegeln**: ein Beleg, der in der v1-Positionsform gelesen wurde, geht hier
+ * in der v2-Form wieder hinaus (wie im Flutter-Vorbild, dessen `toJson` v2
+ * schreibt und dessen `fromJson` beide Formen liest). Nutzlast rein -> Beleg
+ * -> Nutzlast raus ist deshalb kein Rundtrip, wenn die Eingabe v1 war.
+ *
+ * Fuer dieses Paket ohne Folgen: Belege gehen ausschliesslich ueber
+ * `createReceipt` an den Server, das seine Nutzlast selbst baut.
+ */
+export declare function toReceiptPayload(receipt: Receipt): ReceiptPayload;
+export declare function fromReceiptPayload(payload: ReceiptPayloadRead): Receipt;
+/**
+ * Zwischensumme in **Cent** — Positionen plus verkaufte Wertgutscheine minus
+ * eingeloeste Promotionsgutscheine. Wertgutschein-Einloesungen wirken erst auf
+ * [receiptSumCents], nicht hier (siehe Dart-Vorbild `subSumCents`/`sumCents`).
+ */
+export declare function receiptSubSumCents(receipt: Receipt): number;
+/** Gesamtsumme in **Cent** — Zwischensumme minus eingeloeste Wertgutscheine. */
+export declare function receiptSumCents(receipt: Receipt): number;

package/dist/cjs/models/receipt.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toReceiptPayload = toReceiptPayload;
+exports.fromReceiptPayload = fromReceiptPayload;
+exports.receiptSubSumCents = receiptSubSumCents;
+exports.receiptSumCents = receiptSumCents;
+const index_js_1 = require("../enums/index.js");
+const enum_payload_js_1 = require("./enum-payload.js");
+const receipt_item_js_1 = require("./receipt-item.js");
+const voucher_js_1 = require("./voucher.js");
+const receipt_summary_js_1 = require("./receipt-summary.js");
+/**
+ * Schreibt die Nutzlast in der **neuen** Form — sie **normalisiert, statt zu
+ * spiegeln**: ein Beleg, der in der v1-Positionsform gelesen wurde, geht hier
+ * in der v2-Form wieder hinaus (wie im Flutter-Vorbild, dessen `toJson` v2
+ * schreibt und dessen `fromJson` beide Formen liest). Nutzlast rein -> Beleg
+ * -> Nutzlast raus ist deshalb kein Rundtrip, wenn die Eingabe v1 war.
+ *
+ * Fuer dieses Paket ohne Folgen: Belege gehen ausschliesslich ueber
+ * `createReceipt` an den Server, das seine Nutzlast selbst baut.
+ */
+function toReceiptPayload(receipt) {
+    // Schreibpfad bleibt streng: ReceiptType/KeckPaymentMethod sind bekannt am
+    // Objekt-Charakter erkennbar (defineEnum-Eintraege); ein roher String muss
+    // erst durch den Lookup, sonst wirft er.
+    const paymentMethod = typeof receipt.paymentMethod === 'object' ? receipt.paymentMethod : (0, enum_payload_js_1.requireEnumKey)(index_js_1.KeckPaymentMethod, receipt.paymentMethod, 'Zahlungsart');
+    const receiptType = typeof receipt.receiptType === 'object' ? receipt.receiptType : (0, enum_payload_js_1.requireEnumKey)(index_js_1.ReceiptType, receipt.receiptType, 'Belegtyp');
+    return {
+        qr: receipt.qr,
+        sig: receipt.sig,
+        certificateSerialNumber: receipt.certificateSerialNumber,
+        signaturePreviousReceipt: receipt.signaturePreviousReceipt,
+        turnoverCounterAES256ICM: receipt.turnoverCounterAES256ICM,
+        paymentMethod: paymentMethod.value,
+        items: receipt.items.map(receipt_item_js_1.toReceiptItemPayload),
+        vouchers: receipt.vouchers.map(voucher_js_1.toVoucherPayload),
+        timeStamp: receipt.timeStamp,
+        cashregisterId: receipt.cashregisterId,
+        receiptType: receiptType.value,
+        receiptId: receipt.receiptId,
+        fullReceiptId: receipt.fullReceiptId,
+        // CreditCardProvider ist ein flacher String-Enum (kein Objekt-Charakter) —
+        // der Lookup entscheidet hier ausnahmslos, bekannt oder nicht.
+        creditCardProvider: receipt.creditCardProvider != null ? (0, enum_payload_js_1.requireEnumKey)(index_js_1.CreditCardProvider, receipt.creditCardProvider, 'Kartenanbieter') : null,
+        cardPaymentId: receipt.cardPaymentId ?? null,
+        cardPaymentData: receipt.cardPaymentData ?? null,
+        customerDetails: receipt.customerDetails.join('\n'),
+        legalMessage: receipt.legalMessage.join('\n'),
+        signatureSuccess: receipt.signatureSuccess ?? null,
+        customProjectId: receipt.customProjectId ?? null,
+    };
+}
+// Nullbelege haben keine Positionen -> items kann fehlen/null sein (siehe Dart-Vorbild).
+const leereZeile = (text) => (text ? text.split('\n') : []);
+function fromReceiptPayload(payload) {
+    return {
+        receiptId: payload.receiptId,
+        cashregisterId: payload.cashregisterId,
+        timeStamp: payload.timeStamp,
+        items: (payload.items ?? []).map(receipt_item_js_1.fromReceiptItemPayload),
+        vouchers: (payload.vouchers ?? []).map(voucher_js_1.fromVoucherPayload),
+        paymentMethod: (0, enum_payload_js_1.readEnumKey)(index_js_1.KeckPaymentMethod, payload.paymentMethod),
+        turnoverCounterAES256ICM: payload.turnoverCounterAES256ICM,
+        signaturePreviousReceipt: payload.signaturePreviousReceipt,
+        certificateSerialNumber: payload.certificateSerialNumber,
+        receiptType: (0, enum_payload_js_1.readEnumKey)(index_js_1.ReceiptType, payload.receiptType),
+        sig: payload.sig,
+        qr: payload.qr,
+        fullReceiptId: payload.fullReceiptId ?? '',
+        creditCardProvider: payload.creditCardProvider != null ? (0, enum_payload_js_1.readEnumKey)(index_js_1.CreditCardProvider, payload.creditCardProvider) : undefined,
+        cardPaymentId: payload.cardPaymentId ?? undefined,
+        cardPaymentData: payload.cardPaymentData ?? undefined,
+        customerDetails: leereZeile(payload.customerDetails),
+        legalMessage: leereZeile(payload.legalMessage),
+        signatureSuccess: payload.signatureSuccess ?? undefined,
+        customProjectId: payload.customProjectId ?? undefined,
+        ...(payload.cancellationOf ? { cancellationOf: { receiptId: payload.cancellationOf.receiptId, fullReceiptId: payload.cancellationOf.fullReceiptId ?? null } } : {}),
+        ...(payload.cancellationReason ? { cancellationReason: payload.cancellationReason } : {}),
+        ...((0, receipt_summary_js_1.istZeroKind)(payload.zeroKind) ? { zeroKind: payload.zeroKind } : {}),
+        ...(payload.cancellations ? { cancellations: payload.cancellations.map(leseStorno) } : {}),
+    };
+}
+function leseStorno(eintrag) {
+    return {
+        ...(eintrag.receiptId !== undefined ? { receiptId: eintrag.receiptId } : {}),
+        ...(eintrag.pending === true ? { pending: true } : {}),
+        at: Number(eintrag.at ?? 0),
+        by: eintrag.by ?? null,
+        note: eintrag.note ?? null,
+        items: (eintrag.items ?? []).map((p) => ({ index: Number(p.index), quantity: Number(p.quantity) })),
+    };
+}
+/**
+ * Zwischensumme in **Cent** — Positionen plus verkaufte Wertgutscheine minus
+ * eingeloeste Promotionsgutscheine. Wertgutschein-Einloesungen wirken erst auf
+ * [receiptSumCents], nicht hier (siehe Dart-Vorbild `subSumCents`/`sumCents`).
+ */
+function receiptSubSumCents(receipt) {
+    let cents = receipt.items.reduce((acc, item) => acc + (0, receipt_item_js_1.receiptItemTotalCents)(item), 0);
+    for (const voucher of receipt.vouchers) {
+        if (voucher.action === index_js_1.VoucherAction.redeem && voucher.type === index_js_1.VoucherType.promo) {
+            cents -= voucher.valueCents ?? 0;
+        }
+        if (voucher.action === index_js_1.VoucherAction.sell && voucher.type === index_js_1.VoucherType.value) {
+            cents += voucher.valueCents ?? 0;
+        }
+    }
+    return cents;
+}
+/** Gesamtsumme in **Cent** — Zwischensumme minus eingeloeste Wertgutscheine. */
+function receiptSumCents(receipt) {
+    let cents = receiptSubSumCents(receipt);
+    for (const voucher of receipt.vouchers) {
+        if (voucher.action === index_js_1.VoucherAction.redeem && voucher.type === index_js_1.VoucherType.value) {
+            cents -= voucher.valueCents ?? 0;
+        }
+    }
+    return cents;
+}

package/dist/cjs/models/report-month.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Berichtsmonat — Zwilling von `ReportMonth` in
+ * kasseneck_api/lib/models/report_month.dart.
+ *
+ * Hat im Dart-Vorbild bewusst **keine** JSON-Nutzlast (kein `fromJson`/
+ * `toJson`) — es ist ein reiner Kalender-Werttyp fuer Monats-Arithmetik und
+ * Anzeige, kein Beleg-/Backend-Feld. `month` ist die Monatszahl 1-12
+ * (entspricht `KeckMonth.id` im Flutter-Paket) statt eines eigenen Enums —
+ * ein eigenes `KeckMonth`-Enum wuerde hier nur fuer diesen einen Werttyp
+ * Maschinerie aufbauen, die niemand sonst braucht.
+ */
+export interface ReportMonth {
+    month: number;
+    year: number;
+}
+/**
+ * Berichtsmonat eines Zeitpunkts — eingeordnet nach **Wiener** Zeit, nicht
+ * nach der Zeitzone des ausfuehrenden Rechners.
+ *
+ * Der Geschaeftsmonat ist ein oesterreichischer Kalenderwert: ein Beleg vom
+ * 1. Maerz 00:30 Wiener Zeit gehoert in den Maerz, auch wenn derselbe
+ * Zeitpunkt in UTC noch im Februar liegt. Die eingebauten
+ * `getMonth()`/`getFullYear()` wuerden ihn auf einer UTC-Maschine in den
+ * Februar legen und den Monatsbericht auf den falschen Monat schicken.
+ */
+export declare function reportMonthFromDate(date: Date): ReportMonth;
+export declare function previousReportMonth(rm: ReportMonth): ReportMonth;
+export declare function nextReportMonth(rm: ReportMonth): ReportMonth;
+/** Schluessel-Format wie `ReportMonth.toString()` im Flutter-Paket, z. B. `"march_2026"`. */
+export declare function reportMonthKey(rm: ReportMonth): string;
+/** Deutsches Anzeige-Format wie `ReportMonth.readable` im Flutter-Paket, z. B. `"März 2026"`. */
+export declare function reportMonthReadable(rm: ReportMonth): string;

package/dist/cjs/models/report-month.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reportMonthFromDate = reportMonthFromDate;
+exports.previousReportMonth = previousReportMonth;
+exports.nextReportMonth = nextReportMonth;
+exports.reportMonthKey = reportMonthKey;
+exports.reportMonthReadable = reportMonthReadable;
+const vienna_time_js_1 = require("../vienna-time.js");
+// Reihenfolge wie `KeckMonth.values` im Flutter-Paket (Index 0 = Januar).
+const MONTH_KEYS = [
+    'january',
+    'february',
+    'march',
+    'april',
+    'may',
+    'june',
+    'july',
+    'august',
+    'september',
+    'october',
+    'november',
+    'december',
+];
+const MONTH_NAMES_DE = [
+    'Januar',
+    'Februar',
+    'März',
+    'April',
+    'Mai',
+    'Juni',
+    'Juli',
+    'August',
+    'September',
+    'Oktober',
+    'November',
+    'Dezember',
+];
+/**
+ * Berichtsmonat eines Zeitpunkts — eingeordnet nach **Wiener** Zeit, nicht
+ * nach der Zeitzone des ausfuehrenden Rechners.
+ *
+ * Der Geschaeftsmonat ist ein oesterreichischer Kalenderwert: ein Beleg vom
+ * 1. Maerz 00:30 Wiener Zeit gehoert in den Maerz, auch wenn derselbe
+ * Zeitpunkt in UTC noch im Februar liegt. Die eingebauten
+ * `getMonth()`/`getFullYear()` wuerden ihn auf einer UTC-Maschine in den
+ * Februar legen und den Monatsbericht auf den falschen Monat schicken.
+ */
+function reportMonthFromDate(date) {
+    const wanduhr = (0, vienna_time_js_1.toViennaWallClock)(date);
+    return { month: wanduhr.month, year: wanduhr.year };
+}
+function previousReportMonth(rm) {
+    return rm.month === 1 ? { month: 12, year: rm.year - 1 } : { month: rm.month - 1, year: rm.year };
+}
+function nextReportMonth(rm) {
+    return rm.month === 12 ? { month: 1, year: rm.year + 1 } : { month: rm.month + 1, year: rm.year };
+}
+/** Schluessel-Format wie `ReportMonth.toString()` im Flutter-Paket, z. B. `"march_2026"`. */
+function reportMonthKey(rm) {
+    return `${MONTH_KEYS[rm.month - 1]}_${rm.year}`;
+}
+/** Deutsches Anzeige-Format wie `ReportMonth.readable` im Flutter-Paket, z. B. `"März 2026"`. */
+function reportMonthReadable(rm) {
+    return `${MONTH_NAMES_DE[rm.month - 1]} ${rm.year}`;
+}

package/dist/cjs/models/stripe-url-session.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Stripe-Zahlungslink-Sitzung — Zwilling von `StripeUrlSession` in
+ * kasseneck_api/lib/models/stripe_url_seesion.dart.
+ */
+export interface StripeUrlSession {
+    id: string;
+    url: string;
+    shortenUrl: string;
+    expiresAt: Date;
+}
+export interface StripeUrlSessionPayload {
+    id: string;
+    url: string;
+    shorten_payment_url: string;
+    expires_at: string;
+}
+export declare function toStripeUrlSessionPayload(session: StripeUrlSession): StripeUrlSessionPayload;
+export declare function fromStripeUrlSessionPayload(payload: StripeUrlSessionPayload): StripeUrlSession;

package/dist/cjs/models/stripe-url-session.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toStripeUrlSessionPayload = toStripeUrlSessionPayload;
+exports.fromStripeUrlSessionPayload = fromStripeUrlSessionPayload;
+function toStripeUrlSessionPayload(session) {
+    return {
+        id: session.id,
+        url: session.url,
+        shorten_payment_url: session.shortenUrl,
+        expires_at: session.expiresAt.toISOString(),
+    };
+}
+function fromStripeUrlSessionPayload(payload) {
+    return {
+        id: payload.id,
+        url: payload.url,
+        shortenUrl: payload.shorten_payment_url,
+        expiresAt: new Date(payload.expires_at),
+    };
+}

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

@@ -0,0 +1,41 @@
+import { VoucherAction, VoucherType } from '../enums/index.js';
+/**
+ * Gutschein — Zwilling von `KeckVoucher` in
+ * kasseneck_api/lib/models/keck_voucher.dart.
+ *
+ * `valueCents` ist der Gutscheinwert in **Cent** (exakte Integer-Arithmetik).
+ *
+ * `action`/`type` sind schon im Dart-Vorbild reine Strings (keine
+ * Zusatzfelder) — beim Lesen bleibt ein unbekannter Wert deshalb ebenfalls
+ * einfach der rohe Nutzlast-String (siehe [readEnumKey]); ob er zu den
+ * bekannten Werten gehoert, entscheidet sich erst beim Schreiben.
+ */
+export interface Voucher {
+    name?: string;
+    code?: string;
+    action: VoucherAction | string;
+    type: VoucherType | string;
+    valueCents?: number;
+}
+/**
+ * Nutzlast: traegt **beide** Felder, `value` (Euro) und `valueCents` (Cent).
+ * Das Backend erwartet das Euro-Feld weiterhin (Altkompatibilitaet) — die
+ * Umwandlung passiert nur hier, an dieser einen Stelle.
+ */
+export interface VoucherPayload {
+    name: string | null;
+    code: string | null;
+    action: string;
+    type: string;
+    value: number | null;
+    valueCents: number | null;
+}
+export declare function toVoucherPayload(voucher: Voucher): VoucherPayload;
+/**
+ * Ist der Gutschein an das Backend sendbar? Zwilling von `KeckVoucher.isValid`
+ * im Flutter-Vorbild: Wert- und Promotionsgutscheine brauchen einen Wert,
+ * Promotionsgutscheine duerfen nur eingeloest (nicht verkauft) werden, und ein
+ * gesetzter Wert muss positiv sein.
+ */
+export declare function voucherIsValid(voucher: Voucher): boolean;
+export declare function fromVoucherPayload(payload: VoucherPayload): Voucher;

package/dist/cjs/models/voucher.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toVoucherPayload = toVoucherPayload;
+exports.voucherIsValid = voucherIsValid;
+exports.fromVoucherPayload = fromVoucherPayload;
+const index_js_1 = require("../enums/index.js");
+const enum_payload_js_1 = require("./enum-payload.js");
+function toVoucherPayload(voucher) {
+    return {
+        name: voucher.name ?? null,
+        code: voucher.code ?? null,
+        // Schreibpfad bleibt streng: action/type sehen fuer bekannte und
+        // unbekannte Werte gleich aus (reine Strings) — erst der Lookup hier
+        // entscheidet, ob geschrieben werden darf.
+        action: (0, enum_payload_js_1.requireEnumKey)(index_js_1.VoucherAction, voucher.action, 'Gutschein-Aktion'),
+        type: (0, enum_payload_js_1.requireEnumKey)(index_js_1.VoucherType, voucher.type, 'Gutscheinart'),
+        // Euro-Feld nur fuer Altbestand-Konsumenten des Backends — siehe Kommentar oben.
+        value: voucher.valueCents == null ? null : voucher.valueCents / 100,
+        valueCents: voucher.valueCents ?? null,
+    };
+}
+/**
+ * Ist der Gutschein an das Backend sendbar? Zwilling von `KeckVoucher.isValid`
+ * im Flutter-Vorbild: Wert- und Promotionsgutscheine brauchen einen Wert,
+ * Promotionsgutscheine duerfen nur eingeloest (nicht verkauft) werden, und ein
+ * gesetzter Wert muss positiv sein.
+ */
+function voucherIsValid(voucher) {
+    if (voucher.type === index_js_1.VoucherType.value && voucher.valueCents == null) {
+        return false;
+    }
+    if (voucher.type === index_js_1.VoucherType.promo && voucher.action !== index_js_1.VoucherAction.redeem) {
+        return false;
+    }
+    if (voucher.type === index_js_1.VoucherType.promo && voucher.valueCents == null) {
+        return false;
+    }
+    if (voucher.valueCents != null && voucher.valueCents <= 0) {
+        return false;
+    }
+    return true;
+}
+function fromVoucherPayload(payload) {
+    const valueCents = payload.valueCents != null
+        ? payload.valueCents
+        : payload.value != null
+            ? Math.round(payload.value * 100)
+            : undefined;
+    return {
+        name: payload.name ?? undefined,
+        code: payload.code ?? undefined,
+        action: (0, enum_payload_js_1.readEnumKey)(index_js_1.VoucherAction, payload.action),
+        type: (0, enum_payload_js_1.readEnumKey)(index_js_1.VoucherType, payload.type),
+        valueCents,
+    };
+}

package/dist/cjs/money.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Die Grenze zwischen Euro und Cent — an genau einer Stelle.
+ *
+ * Dieses Paket rechnet ausnahmslos in ganzen Cent (siehe README). Euro treten
+ * nur dort auf, wo eine fremde Schnittstelle sie verlangt oder liefert: die
+ * Belegliste des Backends sendet `total`/`umsatz` in Euro, das Hobex-Terminal
+ * nimmt `amount`/`tip` in Euro entgegen. Beide Richtungen stehen hier, damit
+ * die Umrechnung nicht in jeder Datei erneut auftaucht — und damit die
+ * Rundungsregel nur einmal entschieden ist.
+ */
+/** Cent -> Euro, fuer die Schnittstellen, die Euro verlangen. */
+export declare function centsToEuro(cents: number): number;
+/**
+ * Euro -> ganze Cent, fuer Betraege, die aus einer fremden Antwort kommen.
+ *
+ * Unbrauchbare Werte (fehlend, `null`, keine Zahl, NaN, Unendlich) ergeben 0:
+ * eine Belegliste darf nicht daran scheitern, dass ein einzelner Betrag fehlt.
+ *
+ * Gerundet wird **von der Null weg**, nicht mit `Math.round` — das schoebe
+ * `.5` immer Richtung +unendlich, und dann heben sich ein Beleg und sein
+ * Storno im Cent nicht mehr auf (dieselbe Regel wie in receipt/layout.ts).
+ */
+export declare function euroToCents(euro: unknown): number;

package/dist/cjs/money.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * Die Grenze zwischen Euro und Cent — an genau einer Stelle.
+ *
+ * Dieses Paket rechnet ausnahmslos in ganzen Cent (siehe README). Euro treten
+ * nur dort auf, wo eine fremde Schnittstelle sie verlangt oder liefert: die
+ * Belegliste des Backends sendet `total`/`umsatz` in Euro, das Hobex-Terminal
+ * nimmt `amount`/`tip` in Euro entgegen. Beide Richtungen stehen hier, damit
+ * die Umrechnung nicht in jeder Datei erneut auftaucht — und damit die
+ * Rundungsregel nur einmal entschieden ist.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.centsToEuro = centsToEuro;
+exports.euroToCents = euroToCents;
+/** Cent -> Euro, fuer die Schnittstellen, die Euro verlangen. */
+function centsToEuro(cents) {
+    return cents / 100;
+}
+/**
+ * Euro -> ganze Cent, fuer Betraege, die aus einer fremden Antwort kommen.
+ *
+ * Unbrauchbare Werte (fehlend, `null`, keine Zahl, NaN, Unendlich) ergeben 0:
+ * eine Belegliste darf nicht daran scheitern, dass ein einzelner Betrag fehlt.
+ *
+ * Gerundet wird **von der Null weg**, nicht mit `Math.round` — das schoebe
+ * `.5` immer Richtung +unendlich, und dann heben sich ein Beleg und sein
+ * Storno im Cent nicht mehr auf (dieselbe Regel wie in receipt/layout.ts).
+ */
+function euroToCents(euro) {
+    if (typeof euro !== 'number' || !Number.isFinite(euro)) {
+        return 0;
+    }
+    const cents = Math.round(Math.abs(euro) * 100);
+    return euro < 0 ? -cents : cents;
+}

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/cjs/payments/hobex.d.ts

@@ -0,0 +1,87 @@
+import { type HobexReceipt } from '../models/index.js';
+import type { KasseneckTransport } from '../client/transport.js';
+/**
+ * Cent -> Euro. **Die einzige Umrechnungsstelle dieses Moduls.** Betraege
+ * werden im ganzen Paket in Cent gefuehrt (exakte Ganzzahl-Arithmetik); die
+ * Hobex-Schnittstelle erwartet dagegen Euro als Gleitkommazahl (`amount`,
+ * `tip`), und das Backend reicht sie unveraendert an Hobex weiter. Das
+ * Gegenstueck fuer die Antwortrichtung steht in models/hobex-receipt.ts.
+ *
+ * **Geerbte Ungenauigkeit, hier nicht behebbar:** das Backend addiert die
+ * beiden Euro-Werte serverseitig (`check.params.amount + check.params.tip`,
+ * functions/payment-endpoints.js) — aus 10,10 EUR und 0,20 EUR wird dort
+ * `10.299999999999999`. Jede Rundung auf dieser Seite wuerde daran nichts
+ * aendern, weil die Addition erst danach passiert; die saubere Loesung waere
+ * ein Cent-Feld am Backend.
+ */
+export interface HobexPayOptions {
+    /** Kennung der Zahlung — siehe [newHobexTransactionId]. */
+    transactionId: string;
+    /** Zu belastender Betrag in **Cent** (ohne Trinkgeld). */
+    amountCents: number;
+    /** Trinkgeld in **Cent**; Hobex belastet Betrag + Trinkgeld in einem. */
+    tipCents?: number;
+    /** Freier Verwendungszweck, den Hobex mitfuehrt (z. B. Tischnummer). */
+    reference?: string;
+}
+export interface HobexRefundOptions {
+    /** Kennung der zu erstattenden Zahlung. */
+    transactionId: string;
+    /** Zu erstattender Betrag in **Cent** (ohne Trinkgeld). */
+    amountCents: number;
+    /** Zu erstattendes Trinkgeld in **Cent**. */
+    tipCents?: number;
+}
+/** Zeit- und Zufallsquelle von [newHobexTransactionId] — fuer Tests einspeisbar. */
+export interface HobexTransactionIdOptions {
+    /** Zeitpunkt der Kennung; ohne Angabe jetzt. */
+    now?: Date;
+    /** Zufallsquelle in `[0, 1)` wie `Math.random`; ohne Angabe `Math.random`. */
+    random?: () => number;
+}
+/**
+ * Belastet eine Karte ueber die **Hobex-Cloud-API** und liefert den
+ * entstandenen [HobexReceipt].
+ *
+ * **Der Endpunkt heisst `hobexPayApi`** — mit Suffix; ohne ihn gibt es ihn
+ * nicht.
+ */
+export declare function hobexPay(rufen: KasseneckTransport, options: HobexPayOptions): Promise<HobexReceipt>;
+/**
+ * Erstattet eine zuvor ueber die Hobex-Cloud getaetigte Zahlung. Das Backend
+ * storniert zuerst (Void, solange der Tagesabschluss aussteht) und erstattet
+ * erst danach.
+ *
+ * **Ohne Rueckgabewert, mit Absicht.** Das Vorbild liefert
+ * `resJson['status'] == 'success'`; in diesem Paket wirft die Fehlerhuelle
+ * schon im Transport, sobald der Status nicht ausdruecklich Erfolg ist. Ein
+ * Wahrheitswert waere hier also immer `true` — eine Luege ueber den
+ * Informationsgehalt, an der ein Aufrufer ein `if` aufhaengt, das nie greift.
+ * Misserfolg kommt als geworfener Fehler.
+ *
+ * **Der Endpunkt heisst `hobexRefundApi`** — mit Suffix.
+ */
+export declare function hobexRefund(rufen: KasseneckTransport, options: HobexRefundOptions): Promise<void>;
+/**
+ * Erzeugt eine neue Hobex-Transaktionskennung: 19 Ziffern aus Zeitanteil und
+ * Zufall (Zwilling von `newHobexTransactionId` im Vorbild, Zeile 522).
+ *
+ * Zwei bewusste Abweichungen:
+ *
+ * 1. **Wiener Wanduhrzeit statt Geraetezeit.** Das Vorbild nimmt
+ *    `DateTime.now()` in der Zeitzone des Geraets; damit haetten zwei Kassen
+ *    desselben Betriebs in verschiedenen Zeitzonen Kennungen, die sich um
+ *    Stunden unterscheiden, und der Tageswechsel in der Kennung faende nicht
+ *    zum Geschaeftstag statt. Fachlich ist Wien die Zeitzone (siehe
+ *    vienna-time.ts) — und eine Browser-Kasse laeuft in der Zeitzone des Gasts,
+ *    nicht des Betriebs.
+ * 2. **Millisekunden statt Mikrosekunden.** JavaScript hat keine
+ *    Mikrosekunden-Uhr. Das Vorbild fuellt mit sechs Bruchteilsstellen auf und
+ *    haengt zwei Zufallsziffern an, von denen die Laengenbegrenzung eine wieder
+ *    abschneidet; hier stehen drei Bruchteilsstellen und vier Zufallsziffern.
+ *    Laenge und Form (nur Ziffern, 19 Stellen, `JJMMTThhmmss` voran) bleiben
+ *    gleich.
+ *
+ * Zeit- und Zufallsquelle sind einspeisbar, damit die Kennung pruefbar ist.
+ */
+export declare function newHobexTransactionId(options?: HobexTransactionIdOptions): string;