@kreiseck/kasseneck-api 0.6.7

package/dist/esm/enums/stripe-link-mode.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Modus eines Stripe-Zahlungslinks — Zwilling von `StripeLinkMode` in
+ * kasseneck_api/lib/enums/stripe_link_mode.dart.
+ *
+ * `payment` zieht den Betrag sofort ein, `authorization` reserviert ihn nur
+ * (Stripe `capture_method: 'manual'`); eingezogen wird er dann spaeter ueber
+ * `stripeCaptureIntent`.
+ *
+ * Der Wert IST die Nutzlast: das Vorbild sendet `mode.name`, das Backend
+ * vergleicht gegen 'authorization' (functions/payment-endpoints.js).
+ */
+export declare const StripeLinkMode: {
+    readonly payment: "payment";
+    readonly authorization: "authorization";
+};
+export type StripeLinkModeKey = keyof typeof StripeLinkMode;
+export type StripeLinkMode = (typeof StripeLinkMode)[StripeLinkModeKey];

package/dist/esm/enums/stripe-link-mode.js

@@ -0,0 +1,15 @@
+/**
+ * Modus eines Stripe-Zahlungslinks — Zwilling von `StripeLinkMode` in
+ * kasseneck_api/lib/enums/stripe_link_mode.dart.
+ *
+ * `payment` zieht den Betrag sofort ein, `authorization` reserviert ihn nur
+ * (Stripe `capture_method: 'manual'`); eingezogen wird er dann spaeter ueber
+ * `stripeCaptureIntent`.
+ *
+ * Der Wert IST die Nutzlast: das Vorbild sendet `mode.name`, das Backend
+ * vergleicht gegen 'authorization' (functions/payment-endpoints.js).
+ */
+export const StripeLinkMode = {
+    payment: 'payment',
+    authorization: 'authorization',
+};

package/dist/esm/enums/vat-rate.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Steuersatz — Zwilling von `VatRate` in kasseneck_api/lib/enums/vat_rate.dart.
+ *
+ * `category` ist der RKSV-Kategorie-Buchstabe der Steuersaetze (A=20%, B=10%, C=13%,
+ * D=0%, E=19%, G=4,9%). Er haengt an der Signaturkette des Backends — unantastbar.
+ */
+export declare const VatRate: {
+    readonly vat0: {
+        readonly value: "vat0";
+        readonly rate: 0;
+        readonly category: "D";
+    };
+    readonly vat4komma9: {
+        readonly value: "vat4komma9";
+        readonly rate: 4.9;
+        readonly category: "G";
+    };
+    readonly vat10: {
+        readonly value: "vat10";
+        readonly rate: 10;
+        readonly category: "B";
+    };
+    readonly vat13: {
+        readonly value: "vat13";
+        readonly rate: 13;
+        readonly category: "C";
+    };
+    readonly vat19: {
+        readonly value: "vat19";
+        readonly rate: 19;
+        readonly category: "E";
+    };
+    readonly vat20: {
+        readonly value: "vat20";
+        readonly rate: 20;
+        readonly category: "A";
+    };
+};
+export type VatRateKey = keyof typeof VatRate;
+export type VatRate = (typeof VatRate)[VatRateKey];

package/dist/esm/enums/vat-rate.js

@@ -0,0 +1,16 @@
+import { defineEnum } from './define-enum.js';
+/**
+ * Steuersatz — Zwilling von `VatRate` in kasseneck_api/lib/enums/vat_rate.dart.
+ *
+ * `category` ist der RKSV-Kategorie-Buchstabe der Steuersaetze (A=20%, B=10%, C=13%,
+ * D=0%, E=19%, G=4,9%). Er haengt an der Signaturkette des Backends — unantastbar.
+ */
+export const VatRate = defineEnum({
+    vat0: { value: 'vat0', rate: 0, category: 'D' },
+    // Grundnahrungsmittel ab 01.07.2026 -> Betrag-Satz-Besonders (BMF/RKSV)
+    vat4komma9: { value: 'vat4komma9', rate: 4.9, category: 'G' },
+    vat10: { value: 'vat10', rate: 10, category: 'B' },
+    vat13: { value: 'vat13', rate: 13, category: 'C' },
+    vat19: { value: 'vat19', rate: 19, category: 'E' },
+    vat20: { value: 'vat20', rate: 20, category: 'A' },
+});

package/dist/esm/enums/voucher-action.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Gutschein-Aktion — Zwilling von `VoucherAction` in
+ * kasseneck_api/lib/enums/voucher_action.dart.
+ */
+export declare const VoucherAction: {
+    readonly sell: "sell";
+    readonly redeem: "redeem";
+};
+export type VoucherActionKey = keyof typeof VoucherAction;
+export type VoucherAction = (typeof VoucherAction)[VoucherActionKey];

package/dist/esm/enums/voucher-action.js

@@ -0,0 +1,8 @@
+/**
+ * Gutschein-Aktion — Zwilling von `VoucherAction` in
+ * kasseneck_api/lib/enums/voucher_action.dart.
+ */
+export const VoucherAction = {
+    sell: 'sell',
+    redeem: 'redeem',
+};

package/dist/esm/enums/voucher-type.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Gutscheinart — Zwilling von `VoucherType` in kasseneck_api/lib/enums/voucher_type.dart.
+ */
+export declare const VoucherType: {
+    readonly value: "value";
+    readonly promo: "promo";
+};
+export type VoucherTypeKey = keyof typeof VoucherType;
+export type VoucherType = (typeof VoucherType)[VoucherTypeKey];

package/dist/esm/enums/voucher-type.js

@@ -0,0 +1,7 @@
+/**
+ * Gutscheinart — Zwilling von `VoucherType` in kasseneck_api/lib/enums/voucher_type.dart.
+ */
+export const VoucherType = {
+    value: 'value',
+    promo: 'promo',
+};

package/dist/esm/index.d.ts

@@ -0,0 +1,5 @@
+export { ReceiptType, type ReceiptTypeKey, VatRate, type VatRateKey, KeckPaymentMethod, type KeckPaymentMethodKey, CreditCardProvider, type CreditCardProviderKey, VoucherType, type VoucherTypeKey, VoucherAction, type VoucherActionKey, StripeLinkMode, type StripeLinkModeKey, } from './enums/index.js';
+export { type ReceiptItem, type ReceiptItemPayload, type ReceiptItemPayloadRead, toReceiptItemPayload, fromReceiptItemPayload, receiptItemTotalCents, receiptItemIsValid, negateReceiptItem, type Voucher, type VoucherPayload, toVoucherPayload, fromVoucherPayload, voucherIsValid, type Receipt, type ReceiptPayload, type ReceiptPayloadRead, toReceiptPayload, fromReceiptPayload, receiptSubSumCents, receiptSumCents, type CancellationOf, type CancellationItem, type Cancellation, type CancellationReason, CANCELLATION_REASONS, CANCELLATION_RESERVATION_MS, isCancellationReason, remainingQuantities, type ReceiptCompany, type ReceiptCompanyPayload, fromReceiptCompanyPayload, receiptCompanyTaxInfo, type Cashregister, type CashregisterOnboarding, type CashregisterPayload, type CashregisterOnboardingPayload, fromCashregisterPayload, type ReceiptSummary, type ReceiptSummaryPayload, fromReceiptSummaryPayload, type ZeroKind, ZERO_KINDS, istZeroKind, type ReportMonth, reportMonthFromDate, previousReportMonth, nextReportMonth, reportMonthKey, reportMonthReadable, type StripeUrlSession, type StripeUrlSessionPayload, toStripeUrlSessionPayload, fromStripeUrlSessionPayload, type HobexReceipt, type HobexReceiptPayload, toHobexReceiptPayload, fromHobexReceiptPayload, hobexReceiptToCardPaymentData, hobexReceiptNeedsSignature, } from './models/index.js';
+export { type AuthCredentials, type KasseneckAuth, type ApiKeyAuthOptions, type RegisterUserAuthOptions, apiKeyAuth, registerUserAuth, DEFAULT_BASE_URL, DEFAULT_TIMEOUT_MS, type HttpResponseLike, type HttpRequestInit, type FetchLike, type TransportOptions, type TransportBodyFields, type KasseneckTransport, type KasseneckBinaryTransport, createTransport, createBinaryTransport, KasseneckApiError, KasseneckAuthError, KasseneckHttpError, KasseneckNetworkError, KasseneckValidationError, type ValidationScope, type KasseneckError, type HttpFailureReason, type CauseDigest, isKasseneckApiError, isKasseneckAuthError, isKasseneckHttpError, isKasseneckNetworkError, isKasseneckValidationError, type ReceiptCommonOptions, type SellReceiptOptions, type CancelReceiptOptions, type CancelReceiptResult, type CreateCancelReceiptOptions, type ReceiptWithCompany, sellReceipt, sellReceiptWithCompany, cancelReceipt, createCancelReceipt, zeroReceipt, getReceipt, getReceiptWithCompany, generateFullReceiptId, getFirstReceiptDate, listMyReceipts, type ListMyReceiptsOptions, type ReceiptList, type ReceiptListStats, listMyCashregisters, checkVoucherCombinationError, downloadDailyReport, downloadMonthlyReport, type CashboxStatus, type SignatureStatus, getCashboxStatus, getSignatureStatus, type KasseneckApi, createKasseneckApi, } from './client/index.js';
+export { parseServerTimeStamp, toViennaWallClock, type ViennaWallClock } from './vienna-time.js';
+export { type KasseSettingsBetrieb, type KasseSettingsGeraet, type KasseSettings, type ArticleGroup, type KasseArtikel, KASSE_BETRIEB_STANDARD, KASSE_GERAET_STANDARD, mergeKasseSettings, fromArticleGroupPayload, fromKasseArtikelPayload, listMyArticleGroups, listMyArticles, getKasseSettings, setMyKasseSettings, setMyRegisterDeviceSettings, verteileRabatt, cancelScopeOf, receiptsScopeOf, } from './kasse/index.js';

package/dist/esm/index.js

@@ -0,0 +1,5 @@
+export { ReceiptType, VatRate, KeckPaymentMethod, CreditCardProvider, VoucherType, VoucherAction, StripeLinkMode, } from './enums/index.js';
+export { toReceiptItemPayload, fromReceiptItemPayload, receiptItemTotalCents, receiptItemIsValid, negateReceiptItem, toVoucherPayload, fromVoucherPayload, voucherIsValid, toReceiptPayload, fromReceiptPayload, receiptSubSumCents, receiptSumCents, CANCELLATION_REASONS, CANCELLATION_RESERVATION_MS, isCancellationReason, remainingQuantities, fromReceiptCompanyPayload, receiptCompanyTaxInfo, fromCashregisterPayload, fromReceiptSummaryPayload, ZERO_KINDS, istZeroKind, reportMonthFromDate, previousReportMonth, nextReportMonth, reportMonthKey, reportMonthReadable, toStripeUrlSessionPayload, fromStripeUrlSessionPayload, toHobexReceiptPayload, fromHobexReceiptPayload, hobexReceiptToCardPaymentData, hobexReceiptNeedsSignature, } from './models/index.js';
+export { apiKeyAuth, registerUserAuth, DEFAULT_BASE_URL, DEFAULT_TIMEOUT_MS, createTransport, createBinaryTransport, KasseneckApiError, KasseneckAuthError, KasseneckHttpError, KasseneckNetworkError, KasseneckValidationError, isKasseneckApiError, isKasseneckAuthError, isKasseneckHttpError, isKasseneckNetworkError, isKasseneckValidationError, sellReceipt, sellReceiptWithCompany, cancelReceipt, createCancelReceipt, zeroReceipt, getReceipt, getReceiptWithCompany, generateFullReceiptId, getFirstReceiptDate, listMyReceipts, listMyCashregisters, checkVoucherCombinationError, downloadDailyReport, downloadMonthlyReport, getCashboxStatus, getSignatureStatus, createKasseneckApi, } from './client/index.js';
+export { parseServerTimeStamp, toViennaWallClock } from './vienna-time.js';
+export { KASSE_BETRIEB_STANDARD, KASSE_GERAET_STANDARD, mergeKasseSettings, fromArticleGroupPayload, fromKasseArtikelPayload, listMyArticleGroups, listMyArticles, getKasseSettings, setMyKasseSettings, setMyRegisterDeviceSettings, verteileRabatt, cancelScopeOf, receiptsScopeOf, } from './kasse/index.js';

package/dist/esm/kasse/artikel.d.ts

@@ -0,0 +1,83 @@
+import type { KasseneckTransport } from '../client/transport.js';
+/**
+ * Artikelgruppen (Kategorien der Kachel-Kasse) und Artikel in der Form, die
+ * die Kacheln brauchen — Backend: `article-endpoints.js`
+ * (`listMyArticleGroups`, `listMyArticles` mit `groupId`/`kasse`).
+ */
+export interface ArticleGroup {
+    id: string;
+    name: string;
+    /** #RRGGBB */
+    color: string;
+    /** Kategorie-Symbol (Emoji, hoechstens zwei Zeichen) oder null. */
+    symbol: string | null;
+    sort: number;
+    vatRate: number | null;
+}
+export interface ArticleGroupPayload {
+    id?: string | null;
+    name?: string | null;
+    color?: string | null;
+    symbol?: string | null;
+    sort?: number | null;
+    vatRate?: number | null;
+}
+export declare function fromArticleGroupPayload(p: ArticleGroupPayload): ArticleGroup;
+/**
+ * Mengenregel eines Artikels: `stueck` = ganze Stueck (1, 2, 3 ...),
+ * `dezimal` = Kommamenge in der Einheit (0,250 kg, 1,5 m). Beleg und DEP
+ * bleiben ganzzahlig: eine Kommamenge wird an der Kasse als EINE Position mit
+ * ausgerechnetem Betrag gebucht, die Bezeichnung traegt die Menge
+ * („Wurst 0,250 kg“). Siehe [mengenregelFuerEinheit] fuer die Vorgabe je Einheit.
+ */
+export type Mengenregel = 'stueck' | 'dezimal';
+export interface MengenVorgabe {
+    regel: Mengenregel;
+    /** Kasse fragt beim Antippen nach der Menge (Wurst nach Gewicht: ja; Semmel: nein). */
+    fragen: boolean;
+    /** Nachkommastellen bei `dezimal`. */
+    stellen: number;
+}
+/** Vorgabe je Einheit -- was der Betrieb bei einem neuen Artikel bekommt und aendern darf. */
+export declare function mengenregelFuerEinheit(unit: string | null | undefined): MengenVorgabe;
+/** Wirksame Regel eines Artikels: gespeicherte Angabe schlaegt die Vorgabe der Einheit. */
+export declare function mengenVorgabe(a: Pick<KasseArtikel, 'unit' | 'mengenregel' | 'mengeFragen'>): MengenVorgabe;
+/** Artikel, wie ihn die Kasse fuer Kacheln und Belegpositionen braucht. */
+export interface KasseArtikel {
+    id: string;
+    name: string;
+    unitPriceCents: number | null;
+    vatRate: number | null;
+    unit: string;
+    groupId: string | null;
+    sichtbar: boolean;
+    sort: number;
+    active: boolean;
+    /** Gespeicherte Mengenregel; null = Vorgabe der Einheit. */
+    mengenregel: Mengenregel | null;
+    /** Gespeichert: Kasse fragt nach der Menge; null = Vorgabe der Einheit. */
+    mengeFragen: boolean | null;
+    /** Hoechstmenge je Beleg (bei kg/l/m auch Kommazahl); null = keine Grenze. */
+    maxMenge: number | null;
+}
+/** Deckelt eine gewuenschte Menge an der Hoechstmenge des Artikels (null = keine Grenze). */
+export declare function mengeErlaubt(a: Pick<KasseArtikel, 'maxMenge'>, gewuenscht: number): number;
+export interface KasseArtikelPayload {
+    id?: string | null;
+    name?: string | null;
+    unitPriceCents?: number | null;
+    vatRate?: number | null;
+    unit?: string | null;
+    groupId?: string | null;
+    kasse?: {
+        sichtbar?: boolean | null;
+        sort?: number | null;
+    } | null;
+    active?: boolean | null;
+    mengenregel?: string | null;
+    mengeFragen?: boolean | null;
+    maxMenge?: number | null;
+}
+export declare function fromKasseArtikelPayload(p: KasseArtikelPayload): KasseArtikel;
+export declare function listMyArticleGroups(rufen: KasseneckTransport): Promise<ArticleGroup[]>;
+export declare function listMyArticles(rufen: KasseneckTransport): Promise<KasseArtikel[]>;

package/dist/esm/kasse/artikel.js

@@ -0,0 +1,70 @@
+import { KasseneckValidationError } from '../client/errors.js';
+export function fromArticleGroupPayload(p) {
+    return {
+        id: p.id ?? '',
+        name: p.name ?? '',
+        color: p.color ?? '#6B7280',
+        symbol: p.symbol ?? null,
+        sort: typeof p.sort === 'number' ? p.sort : 0,
+        vatRate: typeof p.vatRate === 'number' ? p.vatRate : null,
+    };
+}
+/** Einheiten, die nach Menge verkauft werden (Kommazahl, Kasse fragt). */
+const DEZIMAL_EINHEITEN = {
+    kg: 3, g: 0, l: 2, ml: 0, m: 2, lfm: 2, km: 1, 'm²': 2, m2: 2, 'm³': 3, m3: 3, std: 2, h: 2, min: 0, t: 3,
+};
+/** Vorgabe je Einheit -- was der Betrieb bei einem neuen Artikel bekommt und aendern darf. */
+export function mengenregelFuerEinheit(unit) {
+    const u = (unit ?? '').trim().toLowerCase();
+    if (u in DEZIMAL_EINHEITEN) {
+        const stellen = DEZIMAL_EINHEITEN[u];
+        return stellen === 0
+            ? { regel: 'stueck', fragen: true, stellen: 0 } // g, ml, min: ganze Zahl, aber die Menge wird gefragt
+            : { regel: 'dezimal', fragen: true, stellen };
+    }
+    return { regel: 'stueck', fragen: false, stellen: 0 };
+}
+/** Wirksame Regel eines Artikels: gespeicherte Angabe schlaegt die Vorgabe der Einheit. */
+export function mengenVorgabe(a) {
+    const v = mengenregelFuerEinheit(a.unit);
+    return {
+        regel: a.mengenregel ?? v.regel,
+        fragen: a.mengeFragen ?? v.fragen,
+        stellen: (a.mengenregel ?? v.regel) === 'dezimal' ? Math.max(1, v.stellen || 2) : 0,
+    };
+}
+/** Deckelt eine gewuenschte Menge an der Hoechstmenge des Artikels (null = keine Grenze). */
+export function mengeErlaubt(a, gewuenscht) {
+    return a.maxMenge != null && a.maxMenge > 0 ? Math.min(gewuenscht, a.maxMenge) : gewuenscht;
+}
+export function fromKasseArtikelPayload(p) {
+    return {
+        id: p.id ?? '',
+        name: p.name ?? '',
+        unitPriceCents: typeof p.unitPriceCents === 'number' ? p.unitPriceCents : null,
+        vatRate: typeof p.vatRate === 'number' ? p.vatRate : null,
+        unit: p.unit ?? '',
+        groupId: p.groupId ?? null,
+        sichtbar: p.kasse?.sichtbar !== false,
+        sort: typeof p.kasse?.sort === 'number' ? p.kasse.sort : 0,
+        active: p.active !== false,
+        mengenregel: p.mengenregel === 'stueck' || p.mengenregel === 'dezimal' ? p.mengenregel : null,
+        mengeFragen: typeof p.mengeFragen === 'boolean' ? p.mengeFragen : null,
+        maxMenge: typeof p.maxMenge === 'number' && Number.isFinite(p.maxMenge) && p.maxMenge > 0 ? p.maxMenge : null,
+    };
+}
+function liste(daten, feld, name, lesen) {
+    const roh = daten?.[feld];
+    if (!Array.isArray(roh)) {
+        throw new KasseneckValidationError(name, `Antwort enthaelt keine Liste (data.${feld} fehlt)`, 'response');
+    }
+    return roh.map((e) => lesen(typeof e === 'object' && e !== null ? e : {}));
+}
+export async function listMyArticleGroups(rufen) {
+    const daten = await rufen('listMyArticleGroups');
+    return liste(daten, 'groups', 'listMyArticleGroups', (e) => fromArticleGroupPayload(e));
+}
+export async function listMyArticles(rufen) {
+    const daten = await rufen('listMyArticles');
+    return liste(daten, 'articles', 'listMyArticles', (e) => fromKasseArtikelPayload(e));
+}

package/dist/esm/kasse/client.d.ts

@@ -0,0 +1,10 @@
+import type { KasseneckTransport } from '../client/transport.js';
+import { type KasseSettings, type KasseSettingsBetrieb, type KasseSettingsGeraet } from './settings.js';
+/** Einstellungen lesen — Standard + gespeichert (Backend: `getKasseSettings`). */
+export declare function getKasseSettings(rufen: KasseneckTransport, options?: {
+    deviceId?: string;
+}): Promise<KasseSettings>;
+/** Betriebsweite Einstellungen schreiben (Recht `layout`); liefert den gemischten Stand. */
+export declare function setMyKasseSettings(rufen: KasseneckTransport, betrieb: Partial<KasseSettingsBetrieb>): Promise<KasseSettingsBetrieb>;
+/** Geraete-Einstellungen schreiben (Recht `layout`); liefert den gemischten Stand. */
+export declare function setMyRegisterDeviceSettings(rufen: KasseneckTransport, deviceId: string, geraet: Partial<KasseSettingsGeraet>): Promise<KasseSettingsGeraet>;

package/dist/esm/kasse/client.js

@@ -0,0 +1,33 @@
+import { KasseneckValidationError } from '../client/errors.js';
+import { KASSE_BETRIEB_STANDARD, KASSE_GERAET_STANDARD, mergeKasseSettings, } from './settings.js';
+/** Einstellungen lesen — Standard + gespeichert (Backend: `getKasseSettings`). */
+export async function getKasseSettings(rufen, options = {}) {
+    const params = {};
+    if (options.deviceId)
+        params.deviceId = options.deviceId;
+    const daten = await rufen('getKasseSettings', params);
+    return {
+        betrieb: mergeKasseSettings(KASSE_BETRIEB_STANDARD, (daten?.betrieb ?? null)),
+        geraet: mergeKasseSettings(KASSE_GERAET_STANDARD, (daten?.geraet ?? null)),
+    };
+}
+function nichtLeer(name, block) {
+    if (!block || typeof block !== 'object' || Object.keys(block).length === 0) {
+        throw new KasseneckValidationError(name, 'Keine Einstellungen uebergeben', 'request');
+    }
+}
+/** Betriebsweite Einstellungen schreiben (Recht `layout`); liefert den gemischten Stand. */
+export async function setMyKasseSettings(rufen, betrieb) {
+    nichtLeer('setMyKasseSettings', betrieb);
+    const daten = await rufen('setMyKasseSettings', { betrieb });
+    return mergeKasseSettings(KASSE_BETRIEB_STANDARD, (daten?.betrieb ?? null));
+}
+/** Geraete-Einstellungen schreiben (Recht `layout`); liefert den gemischten Stand. */
+export async function setMyRegisterDeviceSettings(rufen, deviceId, geraet) {
+    if (typeof deviceId !== 'string' || deviceId.trim() === '') {
+        throw new KasseneckValidationError('setMyRegisterDeviceSettings', 'deviceId fehlt', 'request');
+    }
+    nichtLeer('setMyRegisterDeviceSettings', geraet);
+    const daten = await rufen('setMyRegisterDeviceSettings', { deviceId, geraet });
+    return mergeKasseSettings(KASSE_GERAET_STANDARD, (daten?.geraet ?? null));
+}

package/dist/esm/kasse/drucker.d.ts

@@ -0,0 +1,54 @@
+import type { KasseneckTransport } from '../client/transport.js';
+import type { ReceiptLayout } from '../receipt/layout.js';
+/**
+ * Netzwerk-Bondrucker ueber Epson "Server Direct Print": das Backend fuehrt
+ * je Konto Drucker mit einer geheimen Abhol-URL; die Kasse legt Druckjobs
+ * aus einem Zeilenmodell an, der Drucker holt sie selbst ab (alle paar
+ * Sekunden) und meldet das Ergebnis. So druckt jeder Browser -- ohne lokale
+ * Software. Das ePOS-XML baut das Backend aus dem Zeichenraster (ein Setzweg).
+ */
+export interface NetzDrucker {
+    id: string;
+    name: string;
+    art: string;
+    papier: 'mm58' | 'mm80';
+    aktiv: boolean;
+    erstellt: number | null;
+    /** Letzter Abruf des Druckers (ms); null = noch nie verbunden. */
+    zuletztGesehen: number | null;
+    zuletztErgebnis: {
+        erfolg: boolean;
+        code: string | null;
+        zeit: number;
+    } | null;
+    /** Kennung, die der Drucker selbst schickt (Feld ID im Drucker-Menue). */
+    druckerKennung: string | null;
+    /** Abhol-URL fuer das Drucker-Menue -- nur fuer den Chef/das Konto. */
+    sdpUrl?: string;
+}
+export type DruckJobStatus = 'offen' | 'gesendet' | 'gedruckt' | 'fehler' | 'abgelaufen';
+export interface DruckJob {
+    jobId: string;
+    status: DruckJobStatus;
+    erstellt?: number | null;
+    gesendetAt?: number | null;
+    ergebnis: {
+        erfolg: boolean;
+        code: string | null;
+        status?: string | null;
+        zeit?: number;
+    } | null;
+}
+export declare function listMyPrinters(rufen: KasseneckTransport): Promise<NetzDrucker[]>;
+export interface CreatePrintJobOptions {
+    druckerId: string;
+    layout: ReceiptLayout;
+    receiptId?: string;
+    titel?: string;
+    quelle?: string;
+}
+export declare function createPrintJob(rufen: KasseneckTransport, o: CreatePrintJobOptions): Promise<DruckJob>;
+export declare function getPrintJob(rufen: KasseneckTransport, o: {
+    druckerId: string;
+    jobId: string;
+}): Promise<DruckJob>;

package/dist/esm/kasse/drucker.js

@@ -0,0 +1,36 @@
+const text = (v) => (typeof v === 'string' && v ? v : null);
+const zahl = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : null);
+export async function listMyPrinters(rufen) {
+    const daten = await rufen('listMyPrinters', {});
+    return (daten?.drucker ?? []).map((r) => {
+        const d = (r ?? {});
+        const e = d.zuletztErgebnis && typeof d.zuletztErgebnis === 'object' ? d.zuletztErgebnis : null;
+        return {
+            id: String(d.id ?? ''), name: String(d.name ?? ''), art: String(d.art ?? 'epson-sdp'), papier: d.papier === 'mm58' ? 'mm58' : 'mm80',
+            aktiv: d.aktiv !== false, erstellt: zahl(d.erstellt), zuletztGesehen: zahl(d.zuletztGesehen),
+            zuletztErgebnis: e ? { erfolg: e.erfolg === true, code: text(e.code), zeit: zahl(e.zeit) ?? 0 } : null,
+            druckerKennung: text(d.druckerKennung),
+            ...(text(d.sdpUrl) ? { sdpUrl: String(d.sdpUrl) } : {}),
+        };
+    });
+}
+export async function createPrintJob(rufen, o) {
+    const params = { druckerId: o.druckerId, layout: o.layout };
+    if (o.receiptId)
+        params.receiptId = o.receiptId;
+    if (o.titel)
+        params.titel = o.titel;
+    if (o.quelle)
+        params.quelle = o.quelle;
+    const daten = await rufen('createPrintJob', params);
+    return { jobId: String(daten?.jobId ?? ''), status: text(daten?.status) ?? 'offen', ergebnis: null };
+}
+export async function getPrintJob(rufen, o) {
+    const d = await rufen('getPrintJob', { druckerId: o.druckerId, jobId: o.jobId });
+    const e = d?.ergebnis && typeof d.ergebnis === 'object' ? d.ergebnis : null;
+    return {
+        jobId: String(d?.jobId ?? o.jobId), status: text(d?.status) ?? 'offen',
+        erstellt: zahl(d?.erstellt), gesendetAt: zahl(d?.gesendetAt),
+        ergebnis: e ? { erfolg: e.erfolg === true, code: text(e.code), status: text(e.status), zeit: zahl(e.zeit) ?? undefined } : null,
+    };
+}

package/dist/esm/kasse/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Kachel-Kasse: Einstellungen, Artikelgruppen/Artikel fuer Kacheln,
+ * Rabattverteilung. Die Aufrufe heissen 1:1 wie die Backend-Functions
+ * (die Rewrites-Waechter der Web-App leiten daraus ab).
+ */
+export { type KasseStil, type KasseSchrift, type KasseWasserzeichen, type KasseMenge, type KasseTgModus, type KasseKassierenModus, type KasseKartenanbieter, KARTENANBIETER, type KasseBelegAusgabe, type KasseTastenAktion, type KasseTastenkarte, KASSE_TASTEN_AKTIONEN, KASSE_TASTEN_STANDARD, type KasseLayout, type KasseKatpos, type KasseHoehe, type KasseDruckerArt, type KassePapier, type KasseZeichensatz, type KasseSchnitt, type KasseLadeAuto, type Schalterkarte, type KasseSettingsBetrieb, type KasseSettingsGeraet, type KasseSettings, KASSE_BETRIEB_STANDARD, KASSE_GERAET_STANDARD, mergeKasseSettings, } from './settings.js';
+export { type ArticleGroup, type ArticleGroupPayload, fromArticleGroupPayload, type KasseArtikel, type KasseArtikelPayload, fromKasseArtikelPayload, listMyArticleGroups, listMyArticles, type Mengenregel, type MengenVorgabe, mengenregelFuerEinheit, mengenVorgabe, mengeErlaubt, } from './artikel.js';
+export { getKasseSettings, setMyKasseSettings, setMyRegisterDeviceSettings } from './client.js';
+export { verteileRabatt } from '../receipt/discount.js';
+export { cancelScopeOf, receiptsScopeOf, type RegisterScope, type RegisterUserPerms } from '../register/pairing.js';
+export { type NetzDrucker, type DruckJob, type DruckJobStatus, type CreatePrintJobOptions, listMyPrinters, createPrintJob, getPrintJob } from './drucker.js';

package/dist/esm/kasse/index.js

@@ -0,0 +1,13 @@
+/**
+ * Kachel-Kasse: Einstellungen, Artikelgruppen/Artikel fuer Kacheln,
+ * Rabattverteilung. Die Aufrufe heissen 1:1 wie die Backend-Functions
+ * (die Rewrites-Waechter der Web-App leiten daraus ab).
+ */
+export { KARTENANBIETER, KASSE_TASTEN_AKTIONEN, KASSE_TASTEN_STANDARD, KASSE_BETRIEB_STANDARD, KASSE_GERAET_STANDARD, mergeKasseSettings, } from './settings.js';
+export { fromArticleGroupPayload, fromKasseArtikelPayload, listMyArticleGroups, listMyArticles, mengenregelFuerEinheit, mengenVorgabe, mengeErlaubt, } from './artikel.js';
+export { getKasseSettings, setMyKasseSettings, setMyRegisterDeviceSettings } from './client.js';
+export { verteileRabatt } from '../receipt/discount.js';
+// Reichweiten der Kassen-Rechte (Migration wie im Backend) -- bewusst NICHT im
+// Register-Unterpfad: dessen Exportnamen sind 1:1 Function-Namen (Rewrites).
+export { cancelScopeOf, receiptsScopeOf } from '../register/pairing.js';
+export { listMyPrinters, createPrintJob, getPrintJob } from './drucker.js';

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

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

package/dist/esm/kasse/settings.js

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