@kreiseck/kasseneck-api 0.6.7

package/dist/esm/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/esm/models/receipt-item.js

@@ -0,0 +1,101 @@
+import { VatRate } from '../enums/index.js';
+import { readVatRateByRate, requireVatRateByRate } from './enum-payload.js';
+export function toReceiptItemPayload(item) {
+    // Schreibpfad bleibt streng: ein unaufgeloester (unbekannter) Steuersatz
+    // darf nicht unbesehen wieder hinausgehen.
+    const vat = typeof item.vat === 'number' ? 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.
+ */
+export 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 ? readVatRateByRate(satz) : 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.
+ */
+export 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.
+ */
+export 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.
+ */
+export function negateReceiptItem(item) {
+    return { ...item, priceCents: -item.priceCents };
+}

package/dist/esm/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/esm/models/receipt-summary.js

@@ -0,0 +1,49 @@
+import { KeckPaymentMethod, ReceiptType } from '../enums/index.js';
+import { euroToCents } from '../money.js';
+import { readEnumKey } from './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). */
+export const ZERO_KINDS = ['monthly', 'annual', 'annual_replacement', 'outage_end', 'final', 'manual'];
+export function istZeroKind(w) {
+    return typeof w === 'string' && ZERO_KINDS.includes(w);
+}
+export function fromReceiptSummaryPayload(payload) {
+    return {
+        receiptId: payload.receiptId ?? '',
+        ...(typeof payload.counter === 'number' ? { counter: payload.counter } : {}),
+        receiptType: readEnumKey(ReceiptType, payload.receiptType ?? ''),
+        timeStamp: payload.timeStamp ?? '',
+        totalCents: euroToCents(payload.total),
+        paymentMethod: readEnumKey(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 } : {}),
+    };
+}

package/dist/esm/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/esm/models/receipt.js

@@ -0,0 +1,113 @@
+import { ReceiptType, KeckPaymentMethod, CreditCardProvider, VoucherAction, VoucherType } from '../enums/index.js';
+import { readEnumKey, requireEnumKey } from './enum-payload.js';
+import { toReceiptItemPayload, fromReceiptItemPayload, receiptItemTotalCents, } from './receipt-item.js';
+import { toVoucherPayload, fromVoucherPayload } from './voucher.js';
+import { istZeroKind } from './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.
+ */
+export 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 : requireEnumKey(KeckPaymentMethod, receipt.paymentMethod, 'Zahlungsart');
+    const receiptType = typeof receipt.receiptType === 'object' ? receipt.receiptType : requireEnumKey(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(toReceiptItemPayload),
+        vouchers: receipt.vouchers.map(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 ? requireEnumKey(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') : []);
+export function fromReceiptPayload(payload) {
+    return {
+        receiptId: payload.receiptId,
+        cashregisterId: payload.cashregisterId,
+        timeStamp: payload.timeStamp,
+        items: (payload.items ?? []).map(fromReceiptItemPayload),
+        vouchers: (payload.vouchers ?? []).map(fromVoucherPayload),
+        paymentMethod: readEnumKey(KeckPaymentMethod, payload.paymentMethod),
+        turnoverCounterAES256ICM: payload.turnoverCounterAES256ICM,
+        signaturePreviousReceipt: payload.signaturePreviousReceipt,
+        certificateSerialNumber: payload.certificateSerialNumber,
+        receiptType: readEnumKey(ReceiptType, payload.receiptType),
+        sig: payload.sig,
+        qr: payload.qr,
+        fullReceiptId: payload.fullReceiptId ?? '',
+        creditCardProvider: payload.creditCardProvider != null ? readEnumKey(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 } : {}),
+        ...(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`).
+ */
+export function receiptSubSumCents(receipt) {
+    let cents = receipt.items.reduce((acc, item) => acc + receiptItemTotalCents(item), 0);
+    for (const voucher of receipt.vouchers) {
+        if (voucher.action === VoucherAction.redeem && voucher.type === VoucherType.promo) {
+            cents -= voucher.valueCents ?? 0;
+        }
+        if (voucher.action === VoucherAction.sell && voucher.type === VoucherType.value) {
+            cents += voucher.valueCents ?? 0;
+        }
+    }
+    return cents;
+}
+/** Gesamtsumme in **Cent** — Zwischensumme minus eingeloeste Wertgutscheine. */
+export function receiptSumCents(receipt) {
+    let cents = receiptSubSumCents(receipt);
+    for (const voucher of receipt.vouchers) {
+        if (voucher.action === VoucherAction.redeem && voucher.type === VoucherType.value) {
+            cents -= voucher.valueCents ?? 0;
+        }
+    }
+    return cents;
+}

package/dist/esm/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/esm/models/report-month.js

@@ -0,0 +1,58 @@
+import { toViennaWallClock } from '../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.
+ */
+export function reportMonthFromDate(date) {
+    const wanduhr = toViennaWallClock(date);
+    return { month: wanduhr.month, year: wanduhr.year };
+}
+export function previousReportMonth(rm) {
+    return rm.month === 1 ? { month: 12, year: rm.year - 1 } : { month: rm.month - 1, year: rm.year };
+}
+export 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"`. */
+export 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"`. */
+export function reportMonthReadable(rm) {
+    return `${MONTH_NAMES_DE[rm.month - 1]} ${rm.year}`;
+}