@kreiseck/kasseneck-api 0.6.7

package/dist/cjs/models/hobex-receipt.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toHobexReceiptPayload = toHobexReceiptPayload;
+exports.fromHobexReceiptPayload = fromHobexReceiptPayload;
+exports.hobexReceiptToCardPaymentData = hobexReceiptToCardPaymentData;
+exports.hobexReceiptNeedsSignature = hobexReceiptNeedsSignature;
+const index_js_1 = require("../enums/index.js");
+const money_js_1 = require("../money.js");
+function toHobexReceiptPayload(beleg) {
+    return {
+        transactionId: beleg.transactionId,
+        tid: beleg.tid,
+        receipt: beleg.receipt,
+        approvalCode: beleg.approvalCode,
+        reference: beleg.reference ?? null,
+        transactionDate: beleg.transactionDate,
+        cardNumber: beleg.cardNumber,
+        cardExpiry: beleg.cardExpiry,
+        brand: beleg.brand,
+        cardIssuer: beleg.cardIssuer,
+        responseCode: beleg.responseCode,
+        transactionType: beleg.transactionType,
+        currency: beleg.currency,
+        // Euro-Umwandlung nur hier, an der Terminal-API-Grenze — siehe Kommentar oben.
+        amount: (0, money_js_1.centsToEuro)(beleg.amountCents),
+        tip: (0, money_js_1.centsToEuro)(beleg.tipCents),
+        cvm: beleg.cvm,
+    };
+}
+function fromHobexReceiptPayload(payload) {
+    return {
+        transactionId: payload.transactionId,
+        tid: payload.tid,
+        receipt: payload.receipt,
+        approvalCode: payload.approvalCode,
+        reference: payload.reference ?? undefined,
+        // Kappt Bruchteilssekunden/Offset und ersetzt "T" durch ein Leerzeichen,
+        // exakt wie im Dart-Vorbild (transactionDate.split('.')[0].replaceAll('T', ' ')).
+        transactionDate: payload.transactionDate.split('.')[0].split('T').join(' '),
+        cardNumber: payload.cardNumber,
+        cardExpiry: payload.cardExpiry,
+        brand: payload.brand,
+        cardIssuer: payload.cardIssuer,
+        responseCode: payload.responseCode,
+        transactionType: payload.transactionType,
+        currency: payload.currency,
+        amountCents: Math.round((payload.amount ?? 0) * 100),
+        tipCents: Math.round((payload.tip ?? 0) * 100),
+        cvm: String(payload.cvm),
+        // Die Cloud-API-Nutzlast traegt keinen eigenen Provider-Schluessel — der
+        // Provider ergibt sich aus dem Transportweg (Cloud vs. HPS), nicht aus
+        // dem JSON. Das Dart-Vorbild setzt ihn in `fromJson` deshalb ebenfalls
+        // nicht, sondern belaesst den Konstruktor-Default.
+        creditCardProvider: index_js_1.CreditCardProvider.hobexCloudApi,
+    };
+}
+/**
+ * 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.
+ */
+function hobexReceiptToCardPaymentData(beleg) {
+    const data = {
+        transactionId: beleg.transactionId,
+        date: beleg.transactionDate,
+        tid: beleg.tid,
+        no: beleg.receipt,
+        type: beleg.transactionType,
+        cardBrand: beleg.brand,
+        cardNumber: beleg.cardNumber,
+        responseCode: beleg.responseCode,
+        cvm: beleg.cvm,
+    };
+    if (beleg.creditCardProvider === index_js_1.CreditCardProvider.hobexHps) {
+        data.approvalCode = beleg.approvalCode;
+        data.cardExpiry = beleg.cardExpiry;
+        data.cardIssuer = beleg.cardIssuer;
+        data.amount = (0, money_js_1.centsToEuro)(beleg.amountCents).toFixed(2);
+        data.currency = beleg.currency;
+    }
+    return data;
+}
+/** Kartenzahlung erfordert eine Unterschrift (CVM-Code `"1"`). */
+function hobexReceiptNeedsSignature(beleg) {
+    return beleg.cvm === '1';
+}

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

@@ -0,0 +1,10 @@
+export { type ReceiptItem, type ReceiptItemPayload, type ReceiptItemPayloadRead, toReceiptItemPayload, fromReceiptItemPayload, receiptItemTotalCents, receiptItemIsValid, negateReceiptItem, } from './receipt-item.js';
+export { type Voucher, type VoucherPayload, toVoucherPayload, fromVoucherPayload, voucherIsValid } from './voucher.js';
+export { type Receipt, type ReceiptPayload, type ReceiptPayloadRead, toReceiptPayload, fromReceiptPayload, receiptSubSumCents, receiptSumCents, } from './receipt.js';
+export { type CancellationOf, type CancellationItem, type Cancellation, type CancellationReason, CANCELLATION_REASONS, CANCELLATION_RESERVATION_MS, isCancellationReason, remainingQuantities, } from './cancellation.js';
+export { type ReceiptCompany, type ReceiptCompanyPayload, fromReceiptCompanyPayload, receiptCompanyTaxInfo, } from './receipt-company.js';
+export { type Cashregister, type CashregisterOnboarding, type CashregisterPayload, type CashregisterOnboardingPayload, fromCashregisterPayload, } from './cashregister.js';
+export { type ReceiptSummary, type ReceiptSummaryPayload, fromReceiptSummaryPayload, type ZeroKind, ZERO_KINDS, istZeroKind } from './receipt-summary.js';
+export { type ReportMonth, reportMonthFromDate, previousReportMonth, nextReportMonth, reportMonthKey, reportMonthReadable, } from './report-month.js';
+export { type StripeUrlSession, type StripeUrlSessionPayload, toStripeUrlSessionPayload, fromStripeUrlSessionPayload, } from './stripe-url-session.js';
+export { type HobexReceipt, type HobexReceiptPayload, toHobexReceiptPayload, fromHobexReceiptPayload, hobexReceiptToCardPaymentData, hobexReceiptNeedsSignature, } from './hobex-receipt.js';

package/dist/cjs/models/index.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hobexReceiptNeedsSignature = exports.hobexReceiptToCardPaymentData = exports.fromHobexReceiptPayload = exports.toHobexReceiptPayload = exports.fromStripeUrlSessionPayload = exports.toStripeUrlSessionPayload = exports.reportMonthReadable = exports.reportMonthKey = exports.nextReportMonth = exports.previousReportMonth = exports.reportMonthFromDate = exports.istZeroKind = exports.ZERO_KINDS = exports.fromReceiptSummaryPayload = exports.fromCashregisterPayload = exports.receiptCompanyTaxInfo = exports.fromReceiptCompanyPayload = exports.remainingQuantities = exports.isCancellationReason = exports.CANCELLATION_RESERVATION_MS = exports.CANCELLATION_REASONS = exports.receiptSumCents = exports.receiptSubSumCents = exports.fromReceiptPayload = exports.toReceiptPayload = exports.voucherIsValid = exports.fromVoucherPayload = exports.toVoucherPayload = exports.negateReceiptItem = exports.receiptItemIsValid = exports.receiptItemTotalCents = exports.fromReceiptItemPayload = exports.toReceiptItemPayload = void 0;
+var receipt_item_js_1 = require("./receipt-item.js");
+Object.defineProperty(exports, "toReceiptItemPayload", { enumerable: true, get: function () { return receipt_item_js_1.toReceiptItemPayload; } });
+Object.defineProperty(exports, "fromReceiptItemPayload", { enumerable: true, get: function () { return receipt_item_js_1.fromReceiptItemPayload; } });
+Object.defineProperty(exports, "receiptItemTotalCents", { enumerable: true, get: function () { return receipt_item_js_1.receiptItemTotalCents; } });
+Object.defineProperty(exports, "receiptItemIsValid", { enumerable: true, get: function () { return receipt_item_js_1.receiptItemIsValid; } });
+Object.defineProperty(exports, "negateReceiptItem", { enumerable: true, get: function () { return receipt_item_js_1.negateReceiptItem; } });
+var voucher_js_1 = require("./voucher.js");
+Object.defineProperty(exports, "toVoucherPayload", { enumerable: true, get: function () { return voucher_js_1.toVoucherPayload; } });
+Object.defineProperty(exports, "fromVoucherPayload", { enumerable: true, get: function () { return voucher_js_1.fromVoucherPayload; } });
+Object.defineProperty(exports, "voucherIsValid", { enumerable: true, get: function () { return voucher_js_1.voucherIsValid; } });
+var receipt_js_1 = require("./receipt.js");
+Object.defineProperty(exports, "toReceiptPayload", { enumerable: true, get: function () { return receipt_js_1.toReceiptPayload; } });
+Object.defineProperty(exports, "fromReceiptPayload", { enumerable: true, get: function () { return receipt_js_1.fromReceiptPayload; } });
+Object.defineProperty(exports, "receiptSubSumCents", { enumerable: true, get: function () { return receipt_js_1.receiptSubSumCents; } });
+Object.defineProperty(exports, "receiptSumCents", { enumerable: true, get: function () { return receipt_js_1.receiptSumCents; } });
+var cancellation_js_1 = require("./cancellation.js");
+Object.defineProperty(exports, "CANCELLATION_REASONS", { enumerable: true, get: function () { return cancellation_js_1.CANCELLATION_REASONS; } });
+Object.defineProperty(exports, "CANCELLATION_RESERVATION_MS", { enumerable: true, get: function () { return cancellation_js_1.CANCELLATION_RESERVATION_MS; } });
+Object.defineProperty(exports, "isCancellationReason", { enumerable: true, get: function () { return cancellation_js_1.isCancellationReason; } });
+Object.defineProperty(exports, "remainingQuantities", { enumerable: true, get: function () { return cancellation_js_1.remainingQuantities; } });
+var receipt_company_js_1 = require("./receipt-company.js");
+Object.defineProperty(exports, "fromReceiptCompanyPayload", { enumerable: true, get: function () { return receipt_company_js_1.fromReceiptCompanyPayload; } });
+Object.defineProperty(exports, "receiptCompanyTaxInfo", { enumerable: true, get: function () { return receipt_company_js_1.receiptCompanyTaxInfo; } });
+var cashregister_js_1 = require("./cashregister.js");
+Object.defineProperty(exports, "fromCashregisterPayload", { enumerable: true, get: function () { return cashregister_js_1.fromCashregisterPayload; } });
+var receipt_summary_js_1 = require("./receipt-summary.js");
+Object.defineProperty(exports, "fromReceiptSummaryPayload", { enumerable: true, get: function () { return receipt_summary_js_1.fromReceiptSummaryPayload; } });
+Object.defineProperty(exports, "ZERO_KINDS", { enumerable: true, get: function () { return receipt_summary_js_1.ZERO_KINDS; } });
+Object.defineProperty(exports, "istZeroKind", { enumerable: true, get: function () { return receipt_summary_js_1.istZeroKind; } });
+var report_month_js_1 = require("./report-month.js");
+Object.defineProperty(exports, "reportMonthFromDate", { enumerable: true, get: function () { return report_month_js_1.reportMonthFromDate; } });
+Object.defineProperty(exports, "previousReportMonth", { enumerable: true, get: function () { return report_month_js_1.previousReportMonth; } });
+Object.defineProperty(exports, "nextReportMonth", { enumerable: true, get: function () { return report_month_js_1.nextReportMonth; } });
+Object.defineProperty(exports, "reportMonthKey", { enumerable: true, get: function () { return report_month_js_1.reportMonthKey; } });
+Object.defineProperty(exports, "reportMonthReadable", { enumerable: true, get: function () { return report_month_js_1.reportMonthReadable; } });
+var stripe_url_session_js_1 = require("./stripe-url-session.js");
+Object.defineProperty(exports, "toStripeUrlSessionPayload", { enumerable: true, get: function () { return stripe_url_session_js_1.toStripeUrlSessionPayload; } });
+Object.defineProperty(exports, "fromStripeUrlSessionPayload", { enumerable: true, get: function () { return stripe_url_session_js_1.fromStripeUrlSessionPayload; } });
+var hobex_receipt_js_1 = require("./hobex-receipt.js");
+Object.defineProperty(exports, "toHobexReceiptPayload", { enumerable: true, get: function () { return hobex_receipt_js_1.toHobexReceiptPayload; } });
+Object.defineProperty(exports, "fromHobexReceiptPayload", { enumerable: true, get: function () { return hobex_receipt_js_1.fromHobexReceiptPayload; } });
+Object.defineProperty(exports, "hobexReceiptToCardPaymentData", { enumerable: true, get: function () { return hobex_receipt_js_1.hobexReceiptToCardPaymentData; } });
+Object.defineProperty(exports, "hobexReceiptNeedsSignature", { enumerable: true, get: function () { return hobex_receipt_js_1.hobexReceiptNeedsSignature; } });

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

@@ -0,0 +1,71 @@
+/**
+ * Firmen- und Druckdaten eines Belegs — Zwilling der Metadaten von
+ * `KasseneckReceipt` in kasseneck_api/lib/models/kasseneck_receipt.dart
+ * (`toMetadataJson`/`fromMetadata`).
+ *
+ * Das Backend liefert sie **neben** dem Beleg: `getReceipt` und `createReceipt`
+ * legen Firma, Anschrift, Steuernummer, UID, Fusszeilen, Logo-Adresse und das
+ * Kleinunternehmer-Kennzeichen direkt in die Antwort (functions/index.js).
+ * Zum RKSV-Kernbeleg gehoeren sie nicht — sie betreffen ausschliesslich die
+ * Darstellung. Deshalb stehen sie hier als eigenes Modell und nicht in
+ * [Receipt]: derselbe Beleg, spaeter erneut gedruckt, kann eine
+ * zwischenzeitlich geaenderte Fusszeile tragen.
+ *
+ * **Gotcha:** `thanks_message` liefert nur `getReceipt`, `createReceipt`
+ * nicht (functions/index.js, Antwortbloecke von `getReceipt` bzw.
+ * `createReceipt`). Das Feld ist deshalb kein Pflichtfeld der Nutzlast; ohne
+ * es bleibt [thanksMessage] leer.
+ */
+export interface ReceiptCompany {
+    companyName: string;
+    street: string;
+    zip: string;
+    city: string;
+    phone: string;
+    /** UID (Umsatzsteuer-Identifikationsnummer); fehlt bei Kleinunternehmern. */
+    uid?: string;
+    /** Steuernummer des Finanzamts. */
+    taxnr: string;
+    /** Kleinunternehmer nach § 6 Abs 1 Z 27 UStG (keine USt im Ausweis). */
+    isSmallBusiness: boolean;
+    footer1: string;
+    footer2: string;
+    footer3?: string;
+    footer4?: string;
+    /** Adresse des Firmenlogos; dieses Paket laedt und zeichnet es nicht. */
+    logoUrl?: string;
+    /** Dankestext am Belegende, je Zeile ein Eintrag. */
+    thanksMessage: string[];
+    /** Kreiseck-Branding am Belegende (Firestore-Flag `branding.kreiseck_logo`). */
+    showKreiseckLogo: boolean;
+}
+/**
+ * Nutzlast-Form, die dieses Paket **liest** — die Feldnamen der Backend-
+ * Antwort. Alles ist optional: ein Kundendokument ohne gepflegte Anschrift
+ * oder Fusszeile liefert die Felder als `null` oder gar nicht, und ein
+ * fehlender Firmenname darf keinen Belegdruck verhindern.
+ */
+export interface ReceiptCompanyPayload {
+    company?: string | null;
+    street?: string | null;
+    zip?: string | null;
+    city?: string | null;
+    phone?: string | null;
+    uid?: string | null;
+    taxnr?: string | null;
+    is_small_business?: boolean | null;
+    footer1?: string | null;
+    footer2?: string | null;
+    footer3?: string | null;
+    footer4?: string | null;
+    logo_url?: string | null;
+    /** Nur `getReceipt` liefert dieses Feld — siehe Modulkommentar. */
+    thanks_message?: string | null;
+    kreiseck_logo?: boolean | null;
+}
+export declare function fromReceiptCompanyPayload(payload: ReceiptCompanyPayload): ReceiptCompany;
+/**
+ * Steuerangabe im Belegkopf — Zwilling von `KasseneckReceipt.taxInfo`: die UID,
+ * wenn es eine gibt, sonst die Steuernummer.
+ */
+export declare function receiptCompanyTaxInfo(company: ReceiptCompany): string;

package/dist/cjs/models/receipt-company.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromReceiptCompanyPayload = fromReceiptCompanyPayload;
+exports.receiptCompanyTaxInfo = receiptCompanyTaxInfo;
+/** Leere Zeichenkette statt `undefined` — siehe [ReceiptCompanyPayload]. */
+const text = (wert) => (typeof wert === 'string' ? wert : '');
+/**
+ * Zerlegt den Dankestext in Zeilen. Das Vorbild trennt an der **Zeichenfolge**
+ * `\n` (Backslash + n), nicht am Zeilenumbruch — so legt es die Flutter-Seite
+ * auch wieder ab (`toMetadataJson`). Ein echter Zeilenumbruch wird zusaetzlich
+ * getrennt: er kommt aus einem mehrzeiligen Eingabefeld im Panel und wuerde
+ * sonst als Umbruch **innerhalb** einer Layout-Zeile weiterwandern.
+ */
+function zeilen(wert) {
+    if (typeof wert !== 'string' || wert.length === 0) {
+        return [];
+    }
+    return wert.split(/\\n|\r?\n/);
+}
+function fromReceiptCompanyPayload(payload) {
+    const firma = {
+        companyName: text(payload.company),
+        street: text(payload.street),
+        zip: text(payload.zip),
+        city: text(payload.city),
+        phone: text(payload.phone),
+        taxnr: text(payload.taxnr),
+        isSmallBusiness: payload.is_small_business === true,
+        footer1: text(payload.footer1),
+        footer2: text(payload.footer2),
+        thanksMessage: zeilen(payload.thanks_message),
+        showKreiseckLogo: payload.kreiseck_logo === true,
+    };
+    // Die vier Kann-Felder bleiben weg, wenn sie leer sind — ein leerer String
+    // in `footer3` erzeugte sonst eine leere Zeile auf dem Beleg.
+    if (payload.uid)
+        firma.uid = payload.uid;
+    if (payload.footer3)
+        firma.footer3 = payload.footer3;
+    if (payload.footer4)
+        firma.footer4 = payload.footer4;
+    if (payload.logo_url)
+        firma.logoUrl = payload.logo_url;
+    return firma;
+}
+/**
+ * Steuerangabe im Belegkopf — Zwilling von `KasseneckReceipt.taxInfo`: die UID,
+ * wenn es eine gibt, sonst die Steuernummer.
+ */
+function receiptCompanyTaxInfo(company) {
+    return company.uid !== undefined && company.uid.length > 0 ? company.uid : company.taxnr;
+}

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

@@ -0,0 +1,100 @@
+import { VatRate } from '../enums/index.js';
+/**
+ * Belegposition — Zwilling von `KasseneckItem` in
+ * kasseneck_api/lib/models/kasseneck_item.dart.
+ *
+ * `priceCents` ist der Einzelpreis in **Cent** (exakte Integer-Arithmetik,
+ * keine Gleitkomma-Rundungsfehler). Eine Euro-Variante gibt es hier bewusst
+ * nicht — anders als beim Gutschein oder Hobex-Beleg sendet die Nutzlast
+ * (v2-Format) den Preis bereits als ganze Cent.
+ *
+ * `vat` ist beim Lesen entweder der bekannte Steuersatz (Objekt) oder — falls
+ * die Nutzlast einen Satz traegt, den dieses Paket noch nicht kennt — der
+ * rohe `rate`-Wert als Zahl (siehe [readVatRateByRate]). Ein Aufrufer erkennt
+ * den unbekannten Fall am `typeof`: ein Objekt ist bekannt, eine Zahl nicht.
+ *
+ * `quantity` ist beim **Schreiben** eine ganze Menge; TypeScript kennt keinen
+ * Ganzzahltyp, deshalb prueft der Schreibpfad sie zur Laufzeit (siehe
+ * [receiptItemIsValid] und [toReceiptItemPayload]). Beim **Lesen** steht hier,
+ * was in der Nutzlast stand — auch eine gebrochene Menge aus fremder Hand:
+ * lesen tolerant, schreiben streng. `receiptItemTotalCents` liefert dann
+ * folgerichtig einen gebrochenen Cent-Betrag; das ist die Wahrheit des
+ * Belegs, nicht ein Fehler dieses Pakets.
+ */
+export interface ReceiptItem {
+    name: string;
+    /** Ganze Menge, > 0 zum Senden (siehe Klassenkommentar). */
+    quantity: number;
+    vat: VatRate | number;
+    priceCents: number;
+}
+/**
+ * Nutzlast-Form, die dieses Paket **schreibt** (v2):
+ * `{ name, quantity, unitPriceCents, vatRate }`.
+ */
+export interface ReceiptItemPayload {
+    name: string;
+    quantity: number;
+    unitPriceCents: number;
+    vatRate: number;
+}
+/**
+ * Nutzlast-Form, die dieses Paket **liest** — v2 und v1 nebeneinander, alles
+ * optional (Zwilling von `KasseneckItem.fromJson`).
+ *
+ * Das ist kein Entgegenkommen, sondern der Normalfall: Das Backend bildet die
+ * v2-Felder am Eingang auf v1 ab und **speichert v1** (`normalizeMoneyInputs`
+ * in functions/index.js — quantity->amount, vatRate->vat,
+ * unitPriceCents->priceOneCents, daraus priceOne). Ein gespeicherter Beleg
+ * traegt v1 also immer, v2 nur dann, wenn der erzeugende Client sie
+ * mitgesendet hat. Wer hier nur v2 liest, bekommt bei Belegen von
+ * Alt-Clients `undefined` in Menge, Steuersatz und Preis — ohne Fehler, aber
+ * mit `NaN` in jeder Summe und mit einem Beleg, der sich nicht mehr
+ * stornieren laesst.
+ */
+export interface ReceiptItemPayloadRead {
+    name?: string | null;
+    /** v2: Menge */
+    quantity?: number | null;
+    /** v2: Einzelpreis in Cent */
+    unitPriceCents?: number | null;
+    /** v2: Steuersatz */
+    vatRate?: number | null;
+    /** v1: Menge */
+    amount?: number | null;
+    /** v1: Einzelpreis in Cent */
+    priceOneCents?: number | null;
+    /** v1: Einzelpreis in Euro */
+    priceOne?: number | null;
+    /** v1: Steuersatz */
+    vat?: number | null;
+}
+export declare function toReceiptItemPayload(item: ReceiptItem): ReceiptItemPayload;
+/**
+ * Liest beide Nutzlast-Formen (siehe [ReceiptItemPayloadRead]). Reihenfolge
+ * wie im Dart-Vorbild: v2 vor v1, Cent-Angabe vor Euro-Angabe (exakt vor
+ * gerundet); die Euro-Angabe wird genau einmal auf Cent gerundet.
+ */
+export declare function fromReceiptItemPayload(payload: ReceiptItemPayloadRead): ReceiptItem;
+/**
+ * Zeilensumme in Cent. Bei einer selbst erzeugten Position ist sie exakt:
+ * ganze Menge mal ganze Cent. Bei einem fremd erzeugten Beleg mit gebrochener
+ * Menge ist sie folgerichtig gebrochen — das ist der signierte Betrag, und ihn
+ * zu runden hiesse, einen anderen zu drucken.
+ */
+export declare function receiptItemTotalCents(item: ReceiptItem): number;
+/**
+ * Ist die Position an das Backend sendbar? Zwilling von `KasseneckItem.isValid`
+ * im Flutter-Vorbild: ein Name muss da sein und die Menge positiv **und ganz**.
+ * Der Preis darf negativ sein — genau das ist eine Stornoposition.
+ *
+ * Zur Ganzzahligkeit siehe [pruefeMenge]: im Dart-Vorbild ist `quantity` ein
+ * `int`, hier traegt der Typ das nicht, also muss es die Laufzeit tun.
+ */
+export declare function receiptItemIsValid(item: ReceiptItem): boolean;
+/**
+ * Stornoposition zu dieser Position — Zwilling von `KasseneckItem.negative`:
+ * gleicher Name, gleiche Menge, gleicher Steuersatz, **negierter** Einzelpreis.
+ * Die Menge bleibt positiv; das Vorzeichen sitzt ausschliesslich im Preis.
+ */
+export declare function negateReceiptItem(item: ReceiptItem): ReceiptItem;

package/dist/cjs/models/receipt-item.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toReceiptItemPayload = toReceiptItemPayload;
+exports.fromReceiptItemPayload = fromReceiptItemPayload;
+exports.receiptItemTotalCents = receiptItemTotalCents;
+exports.receiptItemIsValid = receiptItemIsValid;
+exports.negateReceiptItem = negateReceiptItem;
+const index_js_1 = require("../enums/index.js");
+const enum_payload_js_1 = require("./enum-payload.js");
+function toReceiptItemPayload(item) {
+    // Schreibpfad bleibt streng: ein unaufgeloester (unbekannter) Steuersatz
+    // darf nicht unbesehen wieder hinausgehen.
+    const vat = typeof item.vat === 'number' ? (0, enum_payload_js_1.requireVatRateByRate)(item.vat) : item.vat;
+    pruefeMenge(item.quantity);
+    return {
+        name: item.name,
+        quantity: item.quantity,
+        unitPriceCents: item.priceCents,
+        vatRate: vat.rate,
+    };
+}
+/**
+ * Liest beide Nutzlast-Formen (siehe [ReceiptItemPayloadRead]). Reihenfolge
+ * wie im Dart-Vorbild: v2 vor v1, Cent-Angabe vor Euro-Angabe (exakt vor
+ * gerundet); die Euro-Angabe wird genau einmal auf Cent gerundet.
+ */
+function fromReceiptItemPayload(payload) {
+    const cents = ersteZahl(payload.unitPriceCents, payload.priceOneCents);
+    const euro = ersteZahl(payload.priceOne);
+    const menge = ersteZahl(payload.quantity, payload.amount);
+    const satz = ersteZahl(payload.vatRate, payload.vat);
+    return {
+        name: payload.name ?? '',
+        // Die Menge kommt herein, wie sie in der Nutzlast steht — auch eine
+        // gebrochene. Sie abzuschneiden (das Dart-Vorbild tut es mit `toInt()`)
+        // waere hier falsch: dort erzwingt es das `int`-Modell der Sprache, hier
+        // gaebe es lautlos einen anderen Betrag als den signierten. Am HTTP-API
+        // haengt auch fremde Software, und das Backend prueft bei den Positionen
+        // allein `unitPriceCents` auf Ganzzahligkeit — ein solcher Beleg ist also
+        // ausstellbar. Er muss sich dann anzeigen und drucken lassen, wie er
+        // signiert wurde. Streng ist stattdessen der Schreibpfad (siehe
+        // [pruefeMenge]): aus diesem Paket geht keine gebrochene Menge hinaus.
+        quantity: menge ?? 0,
+        // Fehlt der Steuersatz voellig, gibt es keinen rohen Wert zum Erhalten;
+        // dann gilt wie im Dart-Vorbild 0 % (das Backend prueft `vat` als Pflicht,
+        // der Fall entsteht also nur bei einer kaputten Nutzlast).
+        vat: satz != null ? (0, enum_payload_js_1.readVatRateByRate)(satz) : index_js_1.VatRate.vat0,
+        priceCents: cents != null ? Math.round(cents) : euro != null ? Math.round(euro * 100) : 0,
+    };
+}
+/** Erster brauchbarer Zahlenwert der Reihe; `null`/`undefined`/NaN zaehlen nicht. */
+function ersteZahl(...werte) {
+    for (const wert of werte) {
+        if (typeof wert === 'number' && Number.isFinite(wert)) {
+            return wert;
+        }
+    }
+    return undefined;
+}
+/**
+ * Zeilensumme in Cent. Bei einer selbst erzeugten Position ist sie exakt:
+ * ganze Menge mal ganze Cent. Bei einem fremd erzeugten Beleg mit gebrochener
+ * Menge ist sie folgerichtig gebrochen — das ist der signierte Betrag, und ihn
+ * zu runden hiesse, einen anderen zu drucken.
+ */
+function receiptItemTotalCents(item) {
+    return item.priceCents * item.quantity;
+}
+/**
+ * Ist die Position an das Backend sendbar? Zwilling von `KasseneckItem.isValid`
+ * im Flutter-Vorbild: ein Name muss da sein und die Menge positiv **und ganz**.
+ * Der Preis darf negativ sein — genau das ist eine Stornoposition.
+ *
+ * Zur Ganzzahligkeit siehe [pruefeMenge]: im Dart-Vorbild ist `quantity` ein
+ * `int`, hier traegt der Typ das nicht, also muss es die Laufzeit tun.
+ */
+function receiptItemIsValid(item) {
+    return item.name.length > 0 && Number.isInteger(item.quantity) && item.quantity > 0;
+}
+/**
+ * Wirft, wenn die Menge keine ganze Zahl ist.
+ *
+ * Der Grund ist keine Formstrenge, sondern die Belegwahrheit: Das Backend
+ * prueft **nur** `unitPriceCents` auf Ganzzahligkeit (`checkItemsIsValid` in
+ * functions/index.js), eine gebrochene Menge kaeme also durch und wuerde
+ * mitsigniert. Der gedruckte Beleg wiese dann einen anderen Betrag aus als der
+ * signierte, und ein Storno darauf traegt eine Menge, die es nie gab. Deshalb
+ * faellt die Menge hier, vor dem Senden, und nicht spaeter still.
+ *
+ * Der Lesepfad tut das ausdruecklich **nicht** (siehe
+ * [fromReceiptItemPayload]): ein fremd erzeugter Beleg muss sich anzeigen
+ * lassen, wie er signiert wurde.
+ *
+ * `Number.isInteger` faengt Bruchteile, NaN und Unendlich in einem.
+ */
+function pruefeMenge(quantity) {
+    if (!Number.isInteger(quantity)) {
+        throw new Error(`Menge: "${quantity}" ist keine ganze Zahl`);
+    }
+}
+/**
+ * Stornoposition zu dieser Position — Zwilling von `KasseneckItem.negative`:
+ * gleicher Name, gleiche Menge, gleicher Steuersatz, **negierter** Einzelpreis.
+ * Die Menge bleibt positiv; das Vorzeichen sitzt ausschliesslich im Preis.
+ */
+function negateReceiptItem(item) {
+    return { ...item, priceCents: -item.priceCents };
+}

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

@@ -0,0 +1,92 @@
+import { KeckPaymentMethod, ReceiptType } from '../enums/index.js';
+/**
+ * Belegzeile einer Liste — die Form, die `listMyReceipts` liefert
+ * (`projectReceiptForCustomer` in functions/index.js).
+ *
+ * **Das ist kein [Receipt].** Die Liste traegt bewusst nur, was eine Uebersicht
+ * braucht: keine Positionen, keine Gutscheine, keine Signatur, keinen QR-Code.
+ * Wer einen Beleg nachdrucken oder stornieren will, holt ihn ueber
+ * `getReceipt`/`getReceiptWithCompany` einzeln — dort steht der vollstaendige,
+ * signierte Beleg.
+ *
+ * `total` kommt vom Backend in **Euro** (auf zwei Stellen gerundet, `round2`).
+ * Dieses Paket rechnet ausnahmslos in ganzen Cent, deshalb wird der Betrag
+ * genau hier, an der Antwortgrenze, einmal umgerechnet — wie beim
+ * Hobex-Beleg.
+ *
+ * `receiptType` und `paymentMethod` sind wie ueberall beim Lesen entweder der
+ * bekannte Enum-Eintrag oder der rohe Nutzlast-Schluessel (siehe
+ * enum-payload.ts): eine Liste darf nicht daran scheitern, dass ein einzelner
+ * Beleg eine Zahlungsart traegt, die dieses Paket noch nicht kennt.
+ */
+/** Anlass eines Nullbelegs (Backend: cashregister-lifecycle ZERO_KINDS). */
+export declare const ZERO_KINDS: readonly ["monthly", "annual", "annual_replacement", "outage_end", "final", "manual"];
+export type ZeroKind = (typeof ZERO_KINDS)[number];
+export declare function istZeroKind(w: unknown): w is ZeroKind;
+export interface ReceiptSummary {
+    receiptId: string;
+    /** Fortlaufender Belegzaehler der Kasse; fehlt bei Alt-Belegen. */
+    counter?: number;
+    receiptType: ReceiptType | string;
+    /** Roher Belegzeitstempel; Deutung ueber `parseServerTimeStamp`. */
+    timeStamp: string;
+    /** Belegsumme in ganzen Cent. */
+    totalCents: number;
+    paymentMethod: KeckPaymentMethod | string;
+    /** `'success'`/`'failed'` der FinanzOnline-Uebermittlung, sofern bekannt. */
+    transmissionStatus?: string;
+    /** Zeitstempel der Uebermittlung, roh wie vom Finanzamt geliefert. */
+    transmissionTime?: string;
+    /**
+     * Wurde der Beleg mit funktionierender Signatureinheit ausgestellt? Das
+     * Backend meldet hier `signatureSuccess !== false`, also `true`, solange
+     * nichts Gegenteiliges vermerkt ist.
+     */
+    signatureOk: boolean;
+    /** Nur fuer Kassen-Benutzer geliefert: Positionen kurz (Name, Menge). */
+    items: Array<{
+        name: string;
+        quantity: number;
+    }>;
+    /** Bediener am Beleg, wenn bekannt. */
+    operator?: {
+        uid: string | null;
+        name: string;
+    };
+    /** Nur am Storno-Beleg: das Original. */
+    cancellationOf?: {
+        receiptId: string | null;
+    };
+    cancellationReason?: string;
+    /** offen | teil | voll -- Storno-Stand des Originals. */
+    stornoStand: 'offen' | 'teil' | 'voll';
+    /** Nur am Nullbeleg, nur fuer Kassen-Benutzer: Anlass (monthly, annual, annual_replacement, outage_end, final, manual). */
+    zeroKind?: ZeroKind;
+}
+export interface ReceiptSummaryPayload {
+    receiptId?: string | null;
+    counter?: number | null;
+    receiptType?: string | null;
+    timeStamp?: string | null;
+    /** Belegsumme in **Euro** (siehe Klassenkommentar). */
+    total?: number | null;
+    paymentMethod?: string | null;
+    transmission_status?: string | null;
+    ts_transmission?: string | null;
+    signature_ok?: boolean | null;
+    items?: Array<{
+        name?: string | null;
+        quantity?: number | null;
+    }> | null;
+    operator?: {
+        uid?: string | null;
+        name?: string | null;
+    } | null;
+    cancellationOf?: {
+        receiptId?: string | null;
+    } | null;
+    cancellationReason?: string | null;
+    stornoStand?: string | null;
+    zeroKind?: string | null;
+}
+export declare function fromReceiptSummaryPayload(payload: ReceiptSummaryPayload): ReceiptSummary;

package/dist/cjs/models/receipt-summary.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZERO_KINDS = void 0;
+exports.istZeroKind = istZeroKind;
+exports.fromReceiptSummaryPayload = fromReceiptSummaryPayload;
+const index_js_1 = require("../enums/index.js");
+const money_js_1 = require("../money.js");
+const enum_payload_js_1 = require("./enum-payload.js");
+/**
+ * Belegzeile einer Liste — die Form, die `listMyReceipts` liefert
+ * (`projectReceiptForCustomer` in functions/index.js).
+ *
+ * **Das ist kein [Receipt].** Die Liste traegt bewusst nur, was eine Uebersicht
+ * braucht: keine Positionen, keine Gutscheine, keine Signatur, keinen QR-Code.
+ * Wer einen Beleg nachdrucken oder stornieren will, holt ihn ueber
+ * `getReceipt`/`getReceiptWithCompany` einzeln — dort steht der vollstaendige,
+ * signierte Beleg.
+ *
+ * `total` kommt vom Backend in **Euro** (auf zwei Stellen gerundet, `round2`).
+ * Dieses Paket rechnet ausnahmslos in ganzen Cent, deshalb wird der Betrag
+ * genau hier, an der Antwortgrenze, einmal umgerechnet — wie beim
+ * Hobex-Beleg.
+ *
+ * `receiptType` und `paymentMethod` sind wie ueberall beim Lesen entweder der
+ * bekannte Enum-Eintrag oder der rohe Nutzlast-Schluessel (siehe
+ * enum-payload.ts): eine Liste darf nicht daran scheitern, dass ein einzelner
+ * Beleg eine Zahlungsart traegt, die dieses Paket noch nicht kennt.
+ */
+/** Anlass eines Nullbelegs (Backend: cashregister-lifecycle ZERO_KINDS). */
+exports.ZERO_KINDS = ['monthly', 'annual', 'annual_replacement', 'outage_end', 'final', 'manual'];
+function istZeroKind(w) {
+    return typeof w === 'string' && exports.ZERO_KINDS.includes(w);
+}
+function fromReceiptSummaryPayload(payload) {
+    return {
+        receiptId: payload.receiptId ?? '',
+        ...(typeof payload.counter === 'number' ? { counter: payload.counter } : {}),
+        receiptType: (0, enum_payload_js_1.readEnumKey)(index_js_1.ReceiptType, payload.receiptType ?? ''),
+        timeStamp: payload.timeStamp ?? '',
+        totalCents: (0, money_js_1.euroToCents)(payload.total),
+        paymentMethod: (0, enum_payload_js_1.readEnumKey)(index_js_1.KeckPaymentMethod, payload.paymentMethod ?? ''),
+        ...(payload.transmission_status ? { transmissionStatus: payload.transmission_status } : {}),
+        ...(payload.ts_transmission ? { transmissionTime: payload.ts_transmission } : {}),
+        // Nur ein ausdrueckliches `false` heisst "ausgefallen" — genau wie im
+        // Backend, das hier `signatureSuccess !== false` sendet.
+        signatureOk: payload.signature_ok !== false,
+        items: Array.isArray(payload.items) ? payload.items.map((i) => ({ name: i?.name ?? '', quantity: typeof i?.quantity === 'number' ? i.quantity : 0 })) : [],
+        ...(payload.operator ? { operator: { uid: payload.operator.uid ?? null, name: payload.operator.name ?? '' } } : {}),
+        ...(payload.cancellationOf ? { cancellationOf: { receiptId: payload.cancellationOf.receiptId ?? null } } : {}),
+        ...(payload.cancellationReason ? { cancellationReason: payload.cancellationReason } : {}),
+        stornoStand: payload.stornoStand === 'teil' || payload.stornoStand === 'voll' ? payload.stornoStand : 'offen',
+        ...(istZeroKind(payload.zeroKind) ? { zeroKind: payload.zeroKind } : {}),
+    };
+}