@kreiseck/kasseneck-api 1.10.0 → 1.11.0

package/dist/cjs/pos/schicht-typen.d.ts

@@ -0,0 +1,380 @@
+/**
+ * Schicht, Kassenstand und Lade-Protokoll: Kataloge und Modelle, wie sie am
+ * Kassenweg `/api/v3` ankommen (Backend schicht-endpoints.js, Vokabular
+ * `KASSEN_BEWEGUNG_ART`, `KASSEN_ORT`, `LADE_OEFFNUNG_GRUND`,
+ * `SCHICHT_BON_ART`). Die Modelle sind die Drahtform, Feld fuer Feld.
+ *
+ * **Fehlt ein Feld, fehlt das Recht.** Ohne `cashView` sendet der Server kein
+ * Soll, kein Ist, keinen Laufstand und keinen Vorschlag (Blindzaehlung); im
+ * Modell fehlen sie dann auch (`undefined`), nie stehen sie als `0` da. Auf
+ * dem Bon (`ShiftSummaryReceipt`) stehen dieselben Werte blind als `null`.
+ *
+ * Alle Betraege in Cent (Ganzzahl, Vorzeichen wie gebucht), Zeiten als
+ * ISO 8601 (UTC), Stueckelung als Karte „Wert in Cent“ -> Anzahl
+ * (`{ "2000": 1, "500": 3 }`).
+ */
+/** Scheine und Muenzen in Euro-Cent, vom groessten Schein abwaerts (Backend `EUR_STUECKELUNG`). */
+export declare const EUR_DENOMINATIONS: readonly [50000, 20000, 10000, 5000, 2000, 1000, 500, 200, 100, 50, 20, 10, 5, 2, 1];
+export type EurDenomination = (typeof EUR_DENOMINATIONS)[number];
+/**
+ * Alle Arten einer Kassenbewegung (Katalog `KASSEN_BEWEGUNG_ART`). Die ersten
+ * acht sendet die Kasse ([MANUAL_MOVEMENT_TYPES]); `transfer_in` (Gegenseite
+ * einer Umbuchung), `expense`, `count_difference` und `handover_difference`
+ * vergibt nur der Server.
+ */
+export declare const MOVEMENT_TYPES: readonly ["change_in", "cash_drop", "owner_deposit", "owner_withdrawal", "tip_payout", "other_in", "other_out", "transfer_out", "transfer_in", "expense", "count_difference", "handover_difference"];
+export type MovementType = (typeof MOVEMENT_TYPES)[number];
+/**
+ * Was die Kasse von Hand buchen darf. Pflichtangaben je Art (sonst lehnt der
+ * Server ab): `note` bei `other_in`/`other_out`, `recipientId` bei
+ * `tip_payout`, `targetDrawerId` bei `transfer_out`. `location` bei
+ * `change_in`/`cash_drop` ist freiwillig.
+ */
+export declare const MANUAL_MOVEMENT_TYPES: readonly ["change_in", "cash_drop", "owner_deposit", "owner_withdrawal", "tip_payout", "other_in", "other_out", "transfer_out"];
+export type ManualMovementType = (typeof MANUAL_MOVEMENT_TYPES)[number];
+/** Woher Wechselgeld kommt bzw. wohin abgeschoepft wird (Katalog `KASSEN_ORT`). */
+export declare const CASH_LOCATIONS: readonly ["bank", "safe"];
+export type CashLocation = (typeof CASH_LOCATIONS)[number];
+/**
+ * Warum die Lade aufging (Katalog `LADE_OEFFNUNG_GRUND`). `sale`,
+ * `cash_movement`, `shift_open` und `shift_close` meldet die Kasse selbst beim
+ * jeweiligen Vorgang; von Hand waehlt der Kassier aus [MANUAL_OPENING_REASONS].
+ */
+export declare const OPENING_REASONS: readonly ["sale", "cash_movement", "shift_open", "shift_close", "change", "check", "misoperation", "other"];
+export type OpeningReason = (typeof OPENING_REASONS)[number];
+/** Die Gruende des Knopfs „Lade“; `other` braucht einen Text (`note`). */
+export declare const MANUAL_OPENING_REASONS: readonly ["change", "check", "misoperation", "other"];
+export type ManualOpeningReason = (typeof MANUAL_OPENING_REASONS)[number];
+/**
+ * Was nach dem Zaehlen beim Schicht-Abschluss mit dem Geld geschieht (Katalog
+ * `NACH_ZAEHLUNG_ART`): `cash_drop` = entnehmen (gebucht als Abschoepfung),
+ * `change_in` = einlegen (gebucht als Wechselgeld). Beides Geldtransit, kein Umsatz.
+ */
+export declare const AFTER_COUNT_TYPES: readonly ["cash_drop", "change_in"];
+export type AfterCountType = (typeof AFTER_COUNT_TYPES)[number];
+/**
+ * Entnehmen oder Einlegen nach dem Zaehlen: `amountCents` immer positiv, die
+ * Richtung sagt `type`. Gezaehlt wird immer die ganze Lade; was danach bleibt,
+ * steht in `leftInDrawerCents` (Schicht, Z-Bon).
+ */
+export interface AfterCount {
+    /** Ein Wert aus [AFTER_COUNT_TYPES] oder ein kuenftiger. */
+    type: AfterCountType | (string & {});
+    amountCents: number;
+}
+/** Arten der Bon-Daten (Katalog `SCHICHT_BON_ART`): Z-Bon, X-Bon, Kassenbewegung. */
+export declare const SHIFT_RECEIPT_KINDS: readonly ["shift_close", "shift_interim", "cash_movement"];
+export type ShiftReceiptKind = (typeof SHIFT_RECEIPT_KINDS)[number];
+export type ShiftStatus = 'open' | 'closed';
+/** Wer gehandelt hat: Kassen-Benutzer, Inhaber (Panel) oder Admin. */
+export type ShiftActorRole = 'register_user' | 'owner' | 'admin';
+/** Stueckelung: Wert in Cent (als Text) -> Anzahl. */
+export type Denominations = Record<string, number>;
+export interface ShiftActor {
+    registerUserId: string | null;
+    name: string | null;
+    role: ShiftActorRole | string;
+}
+export interface DrawerInfo {
+    id: string;
+    name: string | null;
+    /** Schichtbetrieb: verkauft wird erst nach dem Oeffnen einer Schicht. */
+    shiftMode: boolean;
+    cashregisterId: string | null;
+    /**
+     * Wechselgeld der Lade in Cent („Wechselgeld in der Lade“): bleibt nach jedem
+     * Schicht-Abschluss drin, mehr wird beim Schliessen entnommen. Fehlt, wenn
+     * nicht eingestellt (dann bleibt alles in der Lade, wie bisher).
+     */
+    changeFloatCents?: number;
+}
+/** Die vier Rechte des angemeldeten Benutzers an der Lade. */
+export interface DrawerRights {
+    /** Schicht oeffnen und schliessen. */
+    shift: boolean;
+    /** Ein- und Auszahlungen buchen. */
+    cashMove: boolean;
+    /** Soll, Ist und Differenz sehen; ohne dieses Recht wird blind gezaehlt. */
+    cashView: boolean;
+    /** Die Lade von Hand oeffnen (mit Grund). */
+    drawer: boolean;
+}
+export interface NonCashAmount {
+    /** Zahlart, wie am Beleg (`card` …). */
+    method: string;
+    cents: number;
+}
+export interface ShiftTipTotals {
+    registerUserId: string;
+    name: string | null;
+    /** Steht dem Mitarbeiter aus der Lade zu (bar oder Karte am Terminal des Betriebs). */
+    receivedImmediatelyCents: number;
+    /** Behaelt der Betrieb und zahlt es ueber den Lohn („über Lohn“). */
+    retainedCents: number;
+    /** In dieser Schicht aus der Lade ausgezahlt („schon genommen“). */
+    paidOutCents: number;
+    /**
+     * Beim Storno selbst zurueckgegeben („Gibt die Mitarbeiterin direkt“, „selbst zurückgegeben“).
+     * Eigene Zahl, damit „schon genommen“ nie negativ wird: offen = verdient − genommen + selbst
+     * zurueckgegeben. Fehlt es in der Antwort (Backend vor dieser Regel), gilt 0.
+     */
+    refundedByEmployeeCents: number;
+}
+/**
+ * Trinkgeld eines Mitarbeiters mit seinem offenen Anspruch an die Lade
+ * (`openCents`, „offen“): im Kassenstand ([DrawerState.tips]) und auf dem
+ * Z- und X-Bon. Was davon gezeigt wird, sagt [shiftTipLines].
+ */
+export interface ShiftTip extends ShiftTipTotals {
+    /**
+     * Offene Forderung an die Lade beim Oeffnen der Schicht („aus früheren Schichten“, Fix-Runde 2,
+     * R64); ohne offene Schicht der ganze Anspruch. Fehlt es (Backend bzw. Schicht vor dieser Regel), 0.
+     * Fuer den Leser geht auf: offen = aus früheren Schichten + verdient − über Lohn − schon genommen
+     * + selbst zurückgegeben.
+     */
+    carriedOverCents: number;
+    openCents: number;
+}
+/** Laufstand der Schicht (nur mit `cashView`). */
+export interface ShiftRunningTotals {
+    cashSalesCents: number;
+    cashCancellationsCents: number;
+    /** Nach Zahlart sortiert. */
+    nonCashByMethod: NonCashAmount[];
+    /** Eingelöste Gutscheine in Cent (kein Bargeld, nicht in der Lade); fehlt bei älteren Servern, dann 0. */
+    voucherRedeemedCents: number;
+    receiptCount: number;
+    cancellationCount: number;
+    cashInCents: number;
+    cashOutCents: number;
+    /** Nach Name sortiert. */
+    tips: ShiftTipTotals[];
+    openingsWithoutSale: number;
+}
+/** Nachrechnung des Laufstands beim Abschluss: stimmt er, oder welche Felder weichen ab. */
+export interface ShiftReconciliation {
+    matches: boolean;
+    /** Je abweichendem Feld (Name wie in [ShiftRunningTotals]) der gespeicherte und der nachgerechnete Wert. */
+    deviations: Record<string, {
+        stored: unknown;
+        recomputed: unknown;
+    }> | null;
+}
+export interface Shift {
+    id: string;
+    drawerId: string;
+    cashregisterId: string | null;
+    number: number;
+    status: ShiftStatus;
+    openedAt: string | null;
+    openedBy: ShiftActor | null;
+    openedDeviceId?: string | null;
+    closedAt?: string | null;
+    closedBy?: ShiftActor | null;
+    closedDeviceId?: string | null;
+    /** Startgeld; blind `null`, wenn es uebernommen wurde. */
+    openingFloatCents?: number | null;
+    openingDenominations?: Denominations | null;
+    openingFloatTakenOver?: boolean;
+    comment?: string | null;
+    /** Wurde blind gezaehlt (nach dem Abschluss); offen `null`. */
+    blind?: boolean | null;
+    countedCents?: number | null;
+    suggestedFloatCents?: number | null;
+    runningTotals?: ShiftRunningTotals;
+    expectedCents?: number | null;
+    differenceCents?: number | null;
+    reconciliation?: ShiftReconciliation | null;
+    /** Entnommen bzw. eingelegt nach dem Zaehlen. */
+    afterCount?: AfterCount;
+    /** Was danach in der Lade bleibt (Ist ∓ Betrag); fehlt blind (ohne `cashView`). */
+    leftInDrawerCents?: number;
+}
+/** Offener Trinkgeld-Anspruch eines Mitarbeiters (auszahlbar beim Abschluss oder per `tip_payout`). */
+export interface TipClaim {
+    registerUserId: string;
+    name: string | null;
+    cents: number;
+}
+/** Eine gemeldete Oeffnung der Lade (nur mit `cashView`). */
+export interface DrawerOpening {
+    /** Serverzeit des Eingangs. */
+    at: string | null;
+    /** Zeit am Geraet (bei nachgesendeten Oeffnungen frueher als `at`). */
+    deviceTime: string | null;
+    reason: OpeningReason | string;
+    by: {
+        name: string | null;
+    } | null;
+    /** Ging der Impuls an die Lade durch? */
+    ok: boolean;
+}
+/** Stand der Lade fuer die Kasse: Lade, Rechte, Schicht und was das Recht `cashView` zeigt. */
+export interface DrawerState {
+    drawer: DrawerInfo;
+    rights: DrawerRights;
+    /** Die offene Schicht oder `null`; ohne Recht `shift` nur ihre Grunddaten, ohne Betrag (siehe [Shift]). */
+    shift?: Shift | null;
+    /** Schicht seit mindestens 16 Stunden offen; fehlt ohne Recht `shift`. */
+    longOpenWarning?: boolean;
+    tipClaims: TipClaim[];
+    /**
+     * Trinkgeld je Mitarbeiter in der laufenden Schicht und offene Ansprueche
+     * (auch aus frueheren Schichten), nach Name; fuer jede Sitzung, auch ohne
+     * `cashView` (Trinkgeld ist kein Bar-Soll). Wer ueberall 0 hat, fehlt.
+     */
+    tips: ShiftTip[];
+    /** Vorschlag fuer das Startgeld (letzter Stand); bei offener Schicht `null`. Nur mit `shift` und `cashView`. */
+    suggestedFloatCents?: number | null;
+    /** Soll in der Lade; ohne Schicht `null`. Nur mit `shift` und `cashView`. */
+    expectedCents?: number | null;
+    /** Die letzten Oeffnungen, neueste zuerst; nur mit `cashView`. */
+    recentOpenings?: DrawerOpening[];
+    /**
+     * Nummer der Schicht, aus der der Vorschlag stammt („von Schicht {number}
+     * übernommen“). Nur ohne offene Schicht und nur, wenn die letzte Schicht
+     * mit einem Betrag „Bleibt in der Kassenlade“ schloss.
+     */
+    suggestedFromShiftNumber?: number;
+}
+export interface CashMovement {
+    id: string;
+    number: number;
+    shiftId: string | null;
+    type: MovementType | string;
+    /** Mit Vorzeichen: Auszahlungen negativ. */
+    amountCents: number;
+    location: CashLocation | null;
+    note: string | null;
+    by: ShiftActor | null;
+    at: string | null;
+    recipient: {
+        registerUserId: string | null;
+        name: string | null;
+    } | null;
+    /** Gegenbuchung einer Umbuchung in der anderen Lade. */
+    counterpart: {
+        drawerId: string | null;
+        movementId: string | null;
+    } | null;
+}
+/** Kopf jedes Bons der Schicht. */
+export interface ShiftReceiptHeader {
+    kind: ShiftReceiptKind;
+    /** Ohne `cashView` erstellt: Soll, Ist, Differenz und Barumsatz sind `null`. */
+    blind: boolean;
+    business: {
+        name: string | null;
+    };
+    cashregister: {
+        id: string | null;
+        name: string | null;
+    };
+    drawer: {
+        name: string | null;
+    };
+}
+export interface ShiftReceiptMovement {
+    number: number;
+    type: MovementType | string;
+    amountCents: number;
+    note: string | null;
+    byName: string | null;
+    at: string | null;
+}
+/** Trinkgeld auf dem Z- und X-Bon: offen = Anspruch beim Abschluss bzw. jetzt. */
+export type ShiftReceiptTip = ShiftTip;
+/** Bon-Daten des Z-Bons (`shift_close`) bzw. X-Bons (`shift_interim`). */
+export interface ShiftSummaryReceipt extends ShiftReceiptHeader {
+    kind: 'shift_close' | 'shift_interim';
+    shift: {
+        number: number;
+        openedAt: string | null;
+        closedAt: string | null;
+        openedByName: string | null;
+        closedByName: string | null;
+    };
+    openingFloatCents: number | null;
+    openingFloatTakenOver: boolean;
+    openingDenominations: Denominations | null;
+    cashSalesCents: number | null;
+    cashCancellationsCents: number | null;
+    receiptCount: number;
+    cancellationCount: number;
+    nonCashByMethod: NonCashAmount[];
+    movements: ShiftReceiptMovement[];
+    tips: ShiftReceiptTip[];
+    expectedCents: number | null;
+    /** Beim X-Bon immer `null`. */
+    countedCents: number | null;
+    countedDenominations: Denominations | null;
+    differenceCents: number | null;
+    comment: string | null;
+    openingsWithoutSale: number;
+    /** Entnommen bzw. eingelegt nach dem Zaehlen; fehlt, wenn kein Geld bewegt wurde. */
+    afterCount?: AfterCount;
+    /**
+     * „Bleibt in der Kassenlade“; nur zusammen mit `afterCount`, blind `null`
+     * (mit „Entnommen“ ergaebe es sonst das Ist).
+     */
+    leftInDrawerCents?: number | null;
+}
+/** Bon-Daten einer Kassenbewegung. */
+export interface CashMovementReceipt extends ShiftReceiptHeader {
+    kind: 'cash_movement';
+    shift: {
+        number: number;
+    } | null;
+    movement: {
+        number: number;
+        type: MovementType | string;
+        amountCents: number;
+        note: string | null;
+        location: CashLocation | null;
+        recipientName: string | null;
+        targetDrawerName: string | null;
+        byName: string | null;
+        at: string | null;
+    };
+}
+export type ShiftReceipt = ShiftSummaryReceipt | CashMovementReceipt;
+export interface OpenShiftResult {
+    shift: Shift;
+    /** Unterschied zum uebergebenen Bestand beim Zaehlen; nur mit `cashView`. */
+    handoverDifferenceCents?: number | null;
+}
+export interface CashMovementResult {
+    movement: CashMovement;
+    receipt: CashMovementReceipt;
+}
+export interface DrawerOpeningsResult {
+    accepted: number;
+    /** Schon gemeldet (gleicher Schluessel): zaehlt nicht doppelt. */
+    duplicates: number;
+    /** Die Lade, in die gemeldet wurde: eine stillgelegte meldet in die Hauptlade. */
+    drawerId: string | null;
+}
+export interface ShiftReport {
+    shift: Shift;
+    /** Blind ohne `count_difference`/`handover_difference`. */
+    movements: CashMovement[];
+    /** X-Bon (offene Schicht) bzw. Z-Bon zum Nachdruck. */
+    receipt: ShiftSummaryReceipt;
+}
+/**
+ * Ergebnis von `closeMyShift`: `recount` = bitte noch einmal zaehlen (kein
+ * Fehler), `ready` = nur geprueft (`checkOnly`), Schliessen mit diesem Betrag
+ * ginge, `closed` = geschlossen mit Z-Bon.
+ */
+export type CloseShiftResult = {
+    status: 'recount';
+} | {
+    status: 'ready';
+} | {
+    status: 'closed';
+    shift: Shift;
+    receipt: ShiftSummaryReceipt;
+    /** Bon „Kassenbewegung“ der Entnahme bzw. Einlage („Bon fürs Kuvert“); nur wenn Geld bewegt wurde. */
+    afterCountReceipt?: CashMovementReceipt;
+    lastShiftOfRegister: boolean;
+};

package/dist/cjs/pos/schicht-typen.js

@@ -0,0 +1,59 @@
+"use strict";
+/**
+ * Schicht, Kassenstand und Lade-Protokoll: Kataloge und Modelle, wie sie am
+ * Kassenweg `/api/v3` ankommen (Backend schicht-endpoints.js, Vokabular
+ * `KASSEN_BEWEGUNG_ART`, `KASSEN_ORT`, `LADE_OEFFNUNG_GRUND`,
+ * `SCHICHT_BON_ART`). Die Modelle sind die Drahtform, Feld fuer Feld.
+ *
+ * **Fehlt ein Feld, fehlt das Recht.** Ohne `cashView` sendet der Server kein
+ * Soll, kein Ist, keinen Laufstand und keinen Vorschlag (Blindzaehlung); im
+ * Modell fehlen sie dann auch (`undefined`), nie stehen sie als `0` da. Auf
+ * dem Bon (`ShiftSummaryReceipt`) stehen dieselben Werte blind als `null`.
+ *
+ * Alle Betraege in Cent (Ganzzahl, Vorzeichen wie gebucht), Zeiten als
+ * ISO 8601 (UTC), Stueckelung als Karte „Wert in Cent“ -> Anzahl
+ * (`{ "2000": 1, "500": 3 }`).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SHIFT_RECEIPT_KINDS = exports.AFTER_COUNT_TYPES = exports.MANUAL_OPENING_REASONS = exports.OPENING_REASONS = exports.CASH_LOCATIONS = exports.MANUAL_MOVEMENT_TYPES = exports.MOVEMENT_TYPES = exports.EUR_DENOMINATIONS = void 0;
+/** Scheine und Muenzen in Euro-Cent, vom groessten Schein abwaerts (Backend `EUR_STUECKELUNG`). */
+exports.EUR_DENOMINATIONS = Object.freeze([50000, 20000, 10000, 5000, 2000, 1000, 500, 200, 100, 50, 20, 10, 5, 2, 1]);
+/**
+ * Alle Arten einer Kassenbewegung (Katalog `KASSEN_BEWEGUNG_ART`). Die ersten
+ * acht sendet die Kasse ([MANUAL_MOVEMENT_TYPES]); `transfer_in` (Gegenseite
+ * einer Umbuchung), `expense`, `count_difference` und `handover_difference`
+ * vergibt nur der Server.
+ */
+exports.MOVEMENT_TYPES = Object.freeze([
+    'change_in', 'cash_drop', 'owner_deposit', 'owner_withdrawal', 'tip_payout', 'other_in', 'other_out', 'transfer_out',
+    'transfer_in', 'expense', 'count_difference', 'handover_difference',
+]);
+/**
+ * Was die Kasse von Hand buchen darf. Pflichtangaben je Art (sonst lehnt der
+ * Server ab): `note` bei `other_in`/`other_out`, `recipientId` bei
+ * `tip_payout`, `targetDrawerId` bei `transfer_out`. `location` bei
+ * `change_in`/`cash_drop` ist freiwillig.
+ */
+exports.MANUAL_MOVEMENT_TYPES = Object.freeze([
+    'change_in', 'cash_drop', 'owner_deposit', 'owner_withdrawal', 'tip_payout', 'other_in', 'other_out', 'transfer_out',
+]);
+/** Woher Wechselgeld kommt bzw. wohin abgeschoepft wird (Katalog `KASSEN_ORT`). */
+exports.CASH_LOCATIONS = Object.freeze(['bank', 'safe']);
+/**
+ * Warum die Lade aufging (Katalog `LADE_OEFFNUNG_GRUND`). `sale`,
+ * `cash_movement`, `shift_open` und `shift_close` meldet die Kasse selbst beim
+ * jeweiligen Vorgang; von Hand waehlt der Kassier aus [MANUAL_OPENING_REASONS].
+ */
+exports.OPENING_REASONS = Object.freeze([
+    'sale', 'cash_movement', 'shift_open', 'shift_close', 'change', 'check', 'misoperation', 'other',
+]);
+/** Die Gruende des Knopfs „Lade“; `other` braucht einen Text (`note`). */
+exports.MANUAL_OPENING_REASONS = Object.freeze(['change', 'check', 'misoperation', 'other']);
+/**
+ * Was nach dem Zaehlen beim Schicht-Abschluss mit dem Geld geschieht (Katalog
+ * `NACH_ZAEHLUNG_ART`): `cash_drop` = entnehmen (gebucht als Abschoepfung),
+ * `change_in` = einlegen (gebucht als Wechselgeld). Beides Geldtransit, kein Umsatz.
+ */
+exports.AFTER_COUNT_TYPES = Object.freeze(['cash_drop', 'change_in']);
+/** Arten der Bon-Daten (Katalog `SCHICHT_BON_ART`): Z-Bon, X-Bon, Kassenbewegung. */
+exports.SHIFT_RECEIPT_KINDS = Object.freeze(['shift_close', 'shift_interim', 'cash_movement']);

package/dist/cjs/pos/schicht.d.ts

@@ -0,0 +1,208 @@
+import type { InternerTransport } from '../client/aufrufe.js';
+import { type AfterCountType, type CashLocation, type CashMovementResult, type CloseShiftResult, type Denominations, type DrawerOpeningsResult, type DrawerState, type ManualMovementType, type OpeningReason, type OpenShiftResult, type ShiftReport, type ShiftTipTotals } from './schicht-typen.js';
+/**
+ * Schicht, Kassenstand und Lade-Protokoll an der Kasse (Backend
+ * schicht-endpoints.js). Alle sechs Aufrufe gibt es nur ueber den Kassenweg
+ * `/api/v3`; sie laufen mit dem Kassen-Benutzer-Weg (`registerUserAuth`).
+ *
+ * Rechte am Server: `shift` (Schicht oeffnen und schliessen, Bericht),
+ * `cashMove` (Ein- und Auszahlungen), `cashView` (Soll, Ist und Differenz
+ * sehen; ohne dieses Recht wird blind gezaehlt), `drawer` (Lade von Hand
+ * oeffnen). [getMyDrawerState] braucht kein Recht und nennt alle vier.
+ *
+ * **Schreiben mit Idempotenzschluessel:** [openMyShift],
+ * [recordMyCashMovement] und [closeMyShift] verlangen `idempotencyKey`, jeder
+ * Eintrag von [logMyDrawerOpenings] ebenso. Bei unklarem Ausgang
+ * (`outcome: 'unknown'`) denselben Vorgang mit **demselben** Schluessel noch
+ * einmal senden; er wirkt genau einmal. Ein neuer Schluessel ([newIdempotencyKey])
+ * gehoert nur zu einem neuen Vorgang.
+ *
+ * **Vor dem Senden geprueft wird nur, was ohne Netz sicher falsch ist:**
+ * fehlende Kennungen, ein fehlender Schluessel, Betraege, die keine Ganzzahl
+ * sind, eine leere Liste. Alles Fachliche (Katalog, Pflichtangaben je Art,
+ * Kassenstand, Anspruch) prueft der Server und meldet es mit seinem Code.
+ */
+export interface GetMyDrawerStateOptions {
+    /** Ohne Angabe gilt die Hauptlade der Kasse (`cashregisterId`, beim Kassen-Benutzer-Weg die Kasse der Anmeldung). */
+    drawerId?: string;
+    cashregisterId?: string;
+}
+export interface OpenMyShiftOptions {
+    /** Bei „Erneut senden“ derselbe Schluessel wie beim ersten Versuch. */
+    idempotencyKey: string;
+    drawerId: string;
+    /**
+     * Gezaehltes Startgeld in Cent (`0` erlaubt). Genau eines von
+     * `openingFloatCents` und `takeOver: true`.
+     */
+    openingFloatCents?: number;
+    /** Stueckelung zum gezaehlten Startgeld; die Summe muss stimmen ([sumDenominations]). */
+    denominations?: Denominations | null;
+    /** Den Bestand der Vorschicht ungezaehlt uebernehmen („Bestand übernehmen“). */
+    takeOver?: boolean;
+}
+export interface RecordMyCashMovementOptions {
+    idempotencyKey: string;
+    drawerId: string;
+    type: ManualMovementType;
+    /** Positiv; das Vorzeichen setzt der Server nach der Art. */
+    amountCents: number;
+    /** Freiwillig bei `change_in` und `cash_drop` (woher bzw. wohin); ohne Angabe bleibt der Ort leer. */
+    location?: CashLocation;
+    /** Grund; Pflicht bei `other_in` und `other_out`, hoechstens 200 Zeichen. */
+    note?: string;
+    /** Kassen-Benutzer, Pflicht bei `tip_payout`. */
+    recipientId?: string;
+    /** Ziel-Lade, Pflicht bei `transfer_out`. */
+    targetDrawerId?: string;
+}
+/** Eine Oeffnung der Lade, wie die Kasse sie puffert und meldet. */
+export interface DrawerOpeningEntry {
+    /** Je Eintrag ein eigener Schluessel: ein zweites Melden zaehlt nicht doppelt. */
+    idempotencyKey: string;
+    reason: OpeningReason;
+    /** Ging der Impuls an die Lade durch? Fehlgeschlagene werden mit `false` gemeldet. */
+    ok: boolean;
+    /** Zeit am Geraet: Millisekunden seit 1970 oder ISO 8601. */
+    deviceTime: number | string;
+    /** Text, Pflicht bei `other`. */
+    note?: string;
+    /** Beleg bei `sale`. */
+    receiptId?: string;
+    /** Fehlertext eines fehlgeschlagenen Impulses. */
+    error?: string;
+    /** Lade der Oeffnung (gepuffert); muss `drawerId` der Anfrage sein, sonst `validation`. */
+    drawerId?: string;
+    /**
+     * Wer die Lade oeffnete (gepuffert: der damals angemeldete Mitarbeiter). Der
+     * Server nimmt ihn nur, wenn er zum Betrieb gehoert und der Kasse zugewiesen
+     * ist, den Namen aus dem Konto; sonst gilt der sendende Benutzer.
+     */
+    operator?: {
+        registerUserId: string;
+        name?: string | null;
+    };
+}
+export interface LogMyDrawerOpeningsOptions {
+    drawerId: string;
+    /** 1–50 Eintraege; offline gepufferte Oeffnungen werden spaeter nachgesendet. */
+    entries: DrawerOpeningEntry[];
+}
+export interface GetMyShiftReportOptions {
+    shiftId: string;
+}
+/** Trinkgeld-Auszahlung beim Abschluss: hoechstens der offene Anspruch (`DrawerState.tipClaims`). */
+export interface TipPayout {
+    registerUserId: string;
+    cents: number;
+}
+export interface CloseMyShiftOptions {
+    idempotencyKey: string;
+    shiftId: string;
+    /** Gezaehltes Bargeld in Cent (`0` erlaubt). */
+    countedCents: number;
+    denominations?: Denominations | null;
+    /** Wird angenommen, wirkt aber nicht: den Versuch zaehlt der Server (hoechstens zwei). */
+    attempt?: number;
+    /** Begruendung; Pflicht, wenn die Abweichung die Schwelle uebersteigt (`comment_required`). */
+    comment?: string;
+    tipPayouts?: TipPayout[];
+    /**
+     * Nach dem Zaehlen Geld entnehmen (`cash_drop`) oder einlegen (`change_in`),
+     * `amountCents` positiv. Entnehmen hoechstens den gezaehlten Betrag
+     * (`cash_movement_exceeds_balance`); ein Betrag ueber 0 braucht das Recht
+     * `cashMove` (`after_count_not_permitted`). `0` oder ohne Angabe: alles
+     * bleibt in der Lade. Gebucht wird nur beim tatsaechlichen Schliessen, nie bei
+     * `recount`; die Antwort traegt dann `afterCountReceipt` („Bon fürs Kuvert“).
+     */
+    afterCount?: AfterCountOption | null;
+    /**
+     * Nur pruefen, nicht schliessen: dieselbe Pruefung wie beim Schliessen, damit
+     * die Kasse vor „Geld entnehmen“ weiss, ob nachgezaehlt (`recount`) oder
+     * begruendet (`comment_required`) werden muss. Antwort `ready`, wenn das
+     * Schliessen mit diesem Betrag ginge; gebucht wird nichts (auch kein
+     * `afterCount`). Die Zaehlung zaehlt als einer der zwei Versuche; schliesst
+     * danach derselbe Betrag, gilt er als dieselbe Zaehlung.
+     */
+    checkOnly?: boolean;
+}
+/** Entnehmen oder Einlegen beim Abschluss (siehe [CloseMyShiftOptions.afterCount]). */
+export interface AfterCountOption {
+    type: AfterCountType;
+    amountCents: number;
+}
+/** Stand der Lade: Rechte, offene Schicht, Trinkgeld-Ansprueche und (mit `cashView`) Soll und letzte Oeffnungen. */
+export declare function getMyDrawerState(transport: InternerTransport, options?: GetMyDrawerStateOptions): Promise<DrawerState>;
+/** Schicht oeffnen: gezaehltes Startgeld oder den Bestand uebernehmen (Recht `shift`). */
+export declare function openMyShift(transport: InternerTransport, options: OpenMyShiftOptions): Promise<OpenShiftResult>;
+/** Ein- oder Auszahlung buchen (Recht `cashMove`); Antwort mit den Bon-Daten „Kassenbewegung“. */
+export declare function recordMyCashMovement(transport: InternerTransport, options: RecordMyCashMovementOptions): Promise<CashMovementResult>;
+/** Oeffnungen der Lade melden (auch nachgesendet); doppelt gemeldete zaehlen einmal. */
+export declare function logMyDrawerOpenings(transport: InternerTransport, options: LogMyDrawerOpeningsOptions): Promise<DrawerOpeningsResult>;
+/** Bericht der Schicht: Schicht, Bewegungen und Bon-Daten (X-Bon, bei geschlossener Schicht der Z-Bon). */
+export declare function getMyShiftReport(transport: InternerTransport, options: GetMyShiftReportOptions): Promise<ShiftReport>;
+/**
+ * Schicht schliessen (Recht `shift`). `status: 'recount'` heisst: bitte noch
+ * einmal zaehlen und erneut senden (kein Fehler); nach dem zweiten Zaehlen
+ * schliesst der Server, bei grosser Abweichung nur mit `comment`. Mit
+ * `checkOnly` nur pruefen: `status: 'ready'` statt Schliessen.
+ */
+export declare function closeMyShift(transport: InternerTransport, options: CloseMyShiftOptions): Promise<CloseShiftResult>;
+/**
+ * Summe einer Stueckelung in Cent, oder `null`, wenn sie keine ist: ein
+ * Schluessel, der kein Euro-Wert ist ([EUR_DENOMINATIONS], genau so
+ * geschrieben, `"500"`, nicht `"0500"`), eine Anzahl, die keine ganze Zahl
+ * von 0 bis 100 000 ist. Dieselbe Regel wie am Server
+ * (`invalid_denominations`). Gemeinsame Faelle mit dem Dart-Zwilling:
+ * `fixtures/shift-cases.json`.
+ */
+export declare function sumDenominations(denominations: Readonly<Record<string | number, number>>): number | null;
+/**
+ * Ein eingetippter Betrag in Cent, **ohne Gleitkomma**: `'12,5'` → `1250`,
+ * `'0'` → `0` (anders als beim Kassieren ist 0 hier gueltig: eine leere Lade,
+ * kein Startgeld). Dezimaltrenner Komma oder Punkt mit einer oder zwei
+ * Nachkommastellen; `null` fuer leer, Vorzeichen, Tausendertrenner
+ * (`'1.000'`, `'1 000'`), drei Nachkommastellen, Euro-Zeichen und alles
+ * ueber einer sicheren Ganzzahl. Gemeinsame Faelle mit dem Dart-Zwilling:
+ * `fixtures/shift-cases.json`.
+ */
+export declare function parseCentsAllowZero(text: string): number | null;
+/**
+ * Ein frischer Idempotenzschluessel fuer einen neuen Vorgang: `kasse-` und
+ * 32 Hex-Zeichen aus dem sicheren Zufall (`crypto.getRandomValues`), dieselbe
+ * Form wie beim Zaehlen der Inventur in der Kassen-App. Fuer „Erneut senden“
+ * nie einen neuen ziehen, sondern den alten behalten.
+ */
+export declare function newIdempotencyKey(): string;
+/** Zeilen des Trinkgelds eines Mitarbeiters (siehe [shiftTipLines]). */
+export type ShiftTipLineKey = 'shift_receipt.tip_carried_over' | 'shift_receipt.tip_earned' | 'shift_receipt.tip_retained' | 'shift_receipt.tip_paid_out' | 'shift_receipt.tip_refunded_by_employee' | 'shift_receipt.tip_open';
+export interface ShiftTipLine {
+    key: ShiftTipLineKey;
+    /** Das Wort aus dem Katalog ([labelText]). */
+    text: string;
+    cents: number;
+}
+/**
+ * Was vom Trinkgeld eines Mitarbeiters dasteht – auf dem Bon, im Kassenstand
+ * und beim Abschluss gleich (Rulings R50/R51): „verdient“ (sofort + über
+ * Lohn) immer, „über Lohn“, „schon genommen“, „selbst zurückgegeben“ (R62)
+ * und „offen“ nur, wenn nicht 0. Davor „aus früheren Schichten“ (R64, nur ≠ 0):
+ * offen = aus früheren Schichten + verdient − über Lohn − schon genommen +
+ * selbst zurückgegeben.
+ * Ist alles 0, gibt es keine Zeile, und der Mitarbeiter entfaellt ganz. Ohne
+ * `openCents` (Laufstand) zaehlt offen als 0. Gemeinsame Faelle mit dem
+ * Dart-Zwilling: `fixtures/shift-cases.json`.
+ */
+export declare function shiftTipLines(tip: Omit<ShiftTipTotals, 'refundedByEmployeeCents'> & {
+    refundedByEmployeeCents?: number;
+    carriedOverCents?: number;
+    openCents?: number;
+}): ShiftTipLine[];
+/**
+ * Dauer für Menschen aus ganzen Minuten: unter 1 Std. „45 Min.“, unter 1 Tag
+ * „8 Std. 32 Min.“ (bei 0 Minuten nur „8 Std.“), ab 1 Tag „1 Tag 3 Std.“ bzw.
+ * „2 Tage“ (bei 0 Stunden ohne Stunden). Negatives und Unsinn zählt als 0;
+ * Bruchteile werden abgeschnitten. Gemeinsame Fälle mit dem Dart-Zwilling:
+ * `fixtures/shift-cases.json` (`durationText`).
+ */
+export declare function durationText(minutes: number): string;