@kreiseck/kasseneck-api 1.1.1 → 1.2.0

package/dist/esm/models/receipt-errors.d.ts

@@ -16,7 +16,7 @@ import { KasseneckApiError } from '../client/errors.js';
  * ...) stehen in [PAYMENT_ERROR_CODES]. Ein Code ausserhalb bleibt ueber
  * `KasseneckApiError.code` lesbar.
  */
-export declare const RECEIPT_ERROR_CODES: readonly ["cancellation_reference_unavailable", "cashregister_closed", "cashregister_decommissioned", "final_receipt_expired", "final_receipt_not_allowed", "module_inactive", "not_permitted", "receipt_limit_exceeded", "receipt_not_found", "receipt_outcome_unknown", "receipt_type_invalid", "signature_incomplete", "signature_missing", "signing_failed", "small_business_vat_not_allowed", "tip_invalid", "tip_not_allowed", "tip_recipient_unknown", "validation", "account_not_found", "admin_required", "cashregister_not_assigned", "cashregister_not_found", "cashregister_token_invalid", "cashregister_token_missing", "dialect_mismatch", "internal_translation_error", "live_not_enabled", "method_not_allowed", "mfa_required", "not_found", "register_user_no_business", "register_user_not_allowed", "register_user_not_found", "response_translation_failed", "session_expired", "session_other_cashregister", "unauthorized", "user_disabled", "user_verification_failed", "route_missing", "response_unreadable"];
+export declare const RECEIPT_ERROR_CODES: readonly ["cancellation_reference_unavailable", "cashregister_closed", "cashregister_decommissioned", "final_receipt_expired", "final_receipt_not_allowed", "module_inactive", "not_permitted", "receipt_limit_exceeded", "receipt_not_found", "receipt_outcome_unknown", "receipt_type_invalid", "signature_incomplete", "signature_missing", "signing_failed", "small_business_vat_not_allowed", "tip_invalid", "tip_not_allowed", "tip_recipient_unknown", "validation", "account_not_found", "admin_required", "api_not_approved", "cashregister_not_assigned", "cashregister_not_found", "cashregister_token_invalid", "cashregister_token_missing", "dialect_mismatch", "internal_translation_error", "live_not_enabled", "method_not_allowed", "mfa_required", "not_found", "register_user_no_business", "register_user_not_allowed", "register_user_not_found", "response_translation_failed", "session_expired", "session_other_cashregister", "unauthorized", "user_disabled", "user_verification_failed", "route_missing", "response_unreadable"];
 export type ReceiptErrorCode = (typeof RECEIPT_ERROR_CODES)[number];
 export declare function isReceiptErrorCode(value: unknown): value is ReceiptErrorCode;
 /** Der Code eines geworfenen Fehlers, wenn er in [RECEIPT_ERROR_CODES] steht; sonst `undefined`. */

package/dist/esm/models/receipt-errors.js

@@ -39,6 +39,7 @@ export const RECEIPT_ERROR_CODES = Object.freeze([
     // Anmeldung und Rand (errorCodes.auth ohne Partner-Zugang, errorCodes.edge)
     'account_not_found',
     'admin_required',
+    'api_not_approved',
     'cashregister_not_assigned',
     'cashregister_not_found',
     'cashregister_token_invalid',

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

@@ -1,4 +1,5 @@
 import { VatRate } from '../enums/index.js';
+import { type ReturnDisposition } from './cancellation.js';
 /**
  * Belegposition — Zwilling von `KasseneckItem` in
  * kasseneck_api/lib/models/kasseneck_item.dart.
@@ -50,6 +51,10 @@ export interface ReceiptItem {
      * im Bericht. Optional; Handeingaben haben keinen.
      */
     articleId?: string;
+    /** Nur an Storno-Zeilen mit `articleId`: Index der Position im Original. */
+    originalIndex?: number;
+    /** Nur an Storno-Zeilen mit `articleId`: wohin die Ware ging (Lager-Kern Stufe 2). */
+    returnDisposition?: ReturnDisposition;
 }
 /** Empfaenger einer Trinkgeld-Position (Kassen-Benutzer, Snapshot des Namens). */
 export interface TipRecipient {
@@ -117,6 +122,10 @@ export interface ReceiptItemPayloadRead {
     vat?: number | null;
     /** Artikel-Verweis, siehe [ReceiptItem.articleId]. */
     articleId?: string | null;
+    /** Storno-Zeile mit `articleId`: Index im Original, siehe [ReceiptItem.originalIndex]. */
+    originalIndex?: number | null;
+    /** Storno-Zeile mit `articleId`: Rueckgabe-Wahl, siehe [ReceiptItem.returnDisposition]. */
+    returnDisposition?: string | null;
 }
 export declare function toReceiptItemPayload(item: ReceiptItem): ReceiptItemPayload;
 /**

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

@@ -1,5 +1,6 @@
 import { VatRate } from '../enums/index.js';
 import { readVatRateByRate, requireVatRateByRate } from './enum-payload.js';
+import { isReturnDisposition } from './cancellation.js';
 /** Trinkgeld-Position? Die eine Erkennungsstelle — niemand prueft `kind` selbst. */
 export function isTipItem(item) {
     return item != null && item.kind === 'tip';
@@ -80,6 +81,10 @@ export function fromReceiptItemPayload(payload) {
                 : {}),
         // Artikel-Verweis erhalten (Storno-Spiegelung schreibt ihn wieder mit).
         ...(typeof payload.articleId === 'string' && payload.articleId !== '' ? { articleId: payload.articleId } : {}),
+        // Lager: Bezug und Rueckgabe-Wahl einer Storno-Zeile (nur gelesen; ein
+        // unbekannter Wert faellt weg wie am Rand des Servers).
+        ...(Number.isInteger(payload.originalIndex) && payload.originalIndex >= 0 ? { originalIndex: payload.originalIndex } : {}),
+        ...(isReturnDisposition(payload.returnDisposition) ? { returnDisposition: payload.returnDisposition } : {}),
     };
 }
 /** Erster brauchbarer Zahlenwert der Reihe; `null`/`undefined`/NaN zaehlen nicht. */

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

@@ -1,7 +1,7 @@
 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 Cancellation, type CancellationOf, type CancellationReason } from './cancellation.js';
 import { type ZeroKind } from './receipt-summary.js';
 import { type ReceiptPayment, type ReceiptPaymentPayload } from './receipt-payment.js';
 /**

package/dist/esm/models/receipt.js

@@ -2,6 +2,7 @@ import { ReceiptType, KeckPaymentMethod, CreditCardProvider, VoucherAction, Vouc
 import { readEnumKey, requireEnumKey } from './enum-payload.js';
 import { toReceiptItemPayload, fromReceiptItemPayload, receiptItemTotalCents, } from './receipt-item.js';
 import { toVoucherPayload, fromVoucherPayload } from './voucher.js';
+import { isReturnDisposition } from './cancellation.js';
 import { isZeroKind } from './receipt-summary.js';
 import { fromReceiptPaymentPayload, toReceiptPaymentPayload } from './receipt-payment.js';
 /**
@@ -100,7 +101,11 @@ function leseStorno(eintrag) {
         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) })),
+        items: (eintrag.items ?? []).map((p) => ({
+            index: Number(p.index),
+            quantity: Number(p.quantity),
+            ...(isReturnDisposition(p.returnDisposition) ? { returnDisposition: p.returnDisposition } : {}),
+        })),
         ...(eintrag.promoAdjustmentCents && typeof eintrag.promoAdjustmentCents === 'object'
             ? { promoAdjustmentCents: Object.fromEntries(Object.entries(eintrag.promoAdjustmentCents).map(([k, v]) => [k, Number(v)])) }
             : {}),

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

@@ -64,6 +64,14 @@ export interface PosArticle {
     askQuantity: boolean | null;
     /** Hoechstmenge je Beleg (bei kg/l/m auch Kommazahl); null = keine Grenze. */
     maxQuantity: number | null;
+    /**
+     * Standorte, an denen der Artikel gefuehrt wird (Lager-Kern Stufe 2, innen
+     * `standorte`); `null`, wenn der Artikel keine Angabe traegt. Wie die Kasse
+     * daraus Kacheln filtert, entscheidet die Oberflaeche. Optional, damit
+     * bestehende Literale von Verbrauchern weiter uebersetzen; der Leser
+     * (`fromPosArticlePayload`) setzt das Feld immer (`null` oder Liste).
+     */
+    stockLocationIds?: string[] | null;
 }
 /** Deckelt eine gewuenschte Menge an der Hoechstmenge des Artikels (null = keine Grenze). */
 export declare function allowedQuantity(a: Pick<PosArticle, 'maxQuantity'>, wanted: number): number;
@@ -84,7 +92,13 @@ export interface PosArticlePayload {
     quantityRule?: string | null;
     askQuantity?: boolean | null;
     maxQuantity?: number | null;
+    stockLocationIds?: string[] | null;
 }
 export declare function fromPosArticlePayload(p: PosArticlePayload): PosArticle;
+/**
+ * Die Liste `data.<feld>` einer Antwort, jedes Element durch `lesen` (mit
+ * seinem Index fuer Fehlermeldungen). Paketintern: auch `lager.ts` liest so.
+ */
+export declare function liste<T>(daten: unknown, feld: string, name: string, lesen: (e: unknown, index: number) => T): T[];
 export declare function listMyArticleGroups(transport: InternerTransport): Promise<ArticleGroup[]>;
 export declare function listMyArticles(transport: InternerTransport): Promise<PosArticle[]>;

package/dist/esm/pos/artikel.js

@@ -60,14 +60,24 @@ export function fromPosArticlePayload(p) {
         quantityRule: p.quantityRule === 'piece' || p.quantityRule === 'decimal' ? p.quantityRule : null,
         askQuantity: typeof p.askQuantity === 'boolean' ? p.askQuantity : null,
         maxQuantity: typeof p.maxQuantity === 'number' && Number.isFinite(p.maxQuantity) && p.maxQuantity > 0 ? p.maxQuantity : null,
+        stockLocationIds: Array.isArray(p.stockLocationIds)
+            ? p.stockLocationIds.filter((s) => typeof s === 'string' && s !== '')
+            : null,
     };
 }
-function liste(daten, feld, name, lesen) {
+/**
+ * Die Liste `data.<feld>` einer Antwort, jedes Element durch `lesen` (mit
+ * seinem Index fuer Fehlermeldungen). Paketintern: auch `lager.ts` liest so.
+ */
+export 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');
+        const grund = roh === undefined || roh === null
+            ? `Antwort enthaelt keine Liste (data.${feld} fehlt)`
+            : `Antwort ist unbrauchbar (data.${feld} ist keine Liste)`;
+        throw new KasseneckValidationError(name, grund, 'response');
     }
-    return roh.map((e) => lesen(typeof e === 'object' && e !== null ? e : {}));
+    return roh.map((e, i) => lesen(typeof e === 'object' && e !== null ? e : {}, i));
 }
 export async function listMyArticleGroups(transport) {
     const daten = await transport('listMyArticleGroups');

package/dist/esm/pos/errors.d.ts

@@ -1,12 +1,12 @@
 import { KasseneckApiError } from '../client/errors.js';
 /**
  * Fehler der Kassen-Aufrufe um den Verkauf herum (Einstellungen, Logo,
- * Artikel, Drucker, Trinkgeld-Empfaenger) auswerten: am `code`, nie am Text.
+ * Artikel, Drucker, Trinkgeld-Empfaenger, Lager) auswerten: am `code`, nie am Text.
  * Belege, Storno und Belegmail haben eigene Listen (`RECEIPT_ERROR_CODES`,
  * `CANCELLATION_ERROR_CODES`, `RECEIPT_EMAIL_ERROR_CODES`), die Anmeldung
  * `REGISTER_ERROR_CODES` im Unterpfad `./register`.
  *
- * Abgeleitet aus dem Vertrags-Export (Fehlerfaelle dieser zehn Endpunkte in
+ * Abgeleitet aus dem Vertrags-Export (Fehlerfaelle dieser dreizehn Endpunkte in
  * `fixtures/v3/antworten/kasse.json` und ihre Handler-Codes); ein Test haelt
  * die Liste deckungsgleich. `validation` traegt `data.errors[]` mit dem
  * aeusseren Feldpfad (`business.theme`, `device.shortcuts.splitPayment`).
@@ -19,7 +19,7 @@ import { KasseneckApiError } from '../client/errors.js';
  * ueber `KasseneckApiError.code` lesbar; die Kasse braucht dafuer einen
  * Rueckfallzweig.
  */
-export declare const POS_ERROR_CODES: readonly ["account_not_found", "admin_required", "cashregister_not_assigned", "cashregister_not_found", "cashregister_token_invalid", "cashregister_token_missing", "device_not_found", "dialect_mismatch", "internal_translation_error", "live_not_enabled", "logo_invalid", "logo_invalid_type", "logo_too_large", "method_not_allowed", "mfa_required", "module_inactive", "not_found", "not_permitted", "print_job_not_found", "print_layout_failed", "printer_not_found", "register_user_no_business", "register_user_not_allowed", "register_user_not_found", "response_translation_failed", "session_expired", "session_other_cashregister", "unauthorized", "user_disabled", "user_verification_failed", "validation", "route_missing"];
+export declare const POS_ERROR_CODES: readonly ["account_not_found", "admin_required", "api_not_approved", "cashregister_not_assigned", "cashregister_not_found", "cashregister_token_invalid", "cashregister_token_missing", "device_not_found", "dialect_mismatch", "internal_translation_error", "live_not_enabled", "location_inactive", "location_not_found", "logo_invalid", "logo_invalid_type", "logo_too_large", "method_not_allowed", "mfa_required", "module_inactive", "not_found", "not_permitted", "print_job_not_found", "print_layout_failed", "printer_not_found", "register_user_no_business", "register_user_not_allowed", "register_user_not_found", "response_translation_failed", "server_error", "session_expired", "session_other_cashregister", "unauthorized", "user_disabled", "user_verification_failed", "validation", "route_missing"];
 export type PosErrorCode = typeof POS_ERROR_CODES[number];
 export declare function isPosErrorCode(value: unknown): value is PosErrorCode;
 /** Der Code eines geworfenen Fehlers, wenn er in [POS_ERROR_CODES] steht; sonst `undefined`. */

package/dist/esm/pos/errors.js

@@ -1,12 +1,12 @@
 import { KasseneckApiError } from '../client/errors.js';
 /**
  * Fehler der Kassen-Aufrufe um den Verkauf herum (Einstellungen, Logo,
- * Artikel, Drucker, Trinkgeld-Empfaenger) auswerten: am `code`, nie am Text.
+ * Artikel, Drucker, Trinkgeld-Empfaenger, Lager) auswerten: am `code`, nie am Text.
  * Belege, Storno und Belegmail haben eigene Listen (`RECEIPT_ERROR_CODES`,
  * `CANCELLATION_ERROR_CODES`, `RECEIPT_EMAIL_ERROR_CODES`), die Anmeldung
  * `REGISTER_ERROR_CODES` im Unterpfad `./register`.
  *
- * Abgeleitet aus dem Vertrags-Export (Fehlerfaelle dieser zehn Endpunkte in
+ * Abgeleitet aus dem Vertrags-Export (Fehlerfaelle dieser dreizehn Endpunkte in
  * `fixtures/v3/antworten/kasse.json` und ihre Handler-Codes); ein Test haelt
  * die Liste deckungsgleich. `validation` traegt `data.errors[]` mit dem
  * aeusseren Feldpfad (`business.theme`, `device.shortcuts.splitPayment`).
@@ -22,6 +22,7 @@ import { KasseneckApiError } from '../client/errors.js';
 export const POS_ERROR_CODES = Object.freeze([
     'account_not_found',
     'admin_required',
+    'api_not_approved',
     'cashregister_not_assigned',
     'cashregister_not_found',
     'cashregister_token_invalid',
@@ -30,6 +31,8 @@ export const POS_ERROR_CODES = Object.freeze([
     'dialect_mismatch',
     'internal_translation_error',
     'live_not_enabled',
+    'location_inactive',
+    'location_not_found',
     'logo_invalid',
     'logo_invalid_type',
     'logo_too_large',
@@ -45,6 +48,7 @@ export const POS_ERROR_CODES = Object.freeze([
     'register_user_not_allowed',
     'register_user_not_found',
     'response_translation_failed',
+    'server_error',
     'session_expired',
     'session_other_cashregister',
     'unauthorized',

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

@@ -1,6 +1,7 @@
 /**
  * Kachel-Kasse: Einstellungen, Artikelgruppen/Artikel fuer Kacheln,
- * Rabattverteilung, Drucker, Trinkgeld-Empfaenger. Die Aufrufe heissen 1:1 wie
+ * Rabattverteilung, Drucker, Trinkgeld-Empfaenger, Lager (Standorte, Bestand,
+ * Standort der Kasse). Die Aufrufe heissen 1:1 wie
  * die Backend-Functions (die Rewrites-Waechter der Web-App leiten daraus ab)
  * und sprechen den Kassenweg `/api/v3` (Schluessel und Werte englisch).
  */
@@ -9,7 +10,9 @@ export { type ArticleGroup, type ArticleGroupPayload, fromArticleGroupPayload, t
 export { getPosSettings, setMyPosSettings, setMyRegisterDeviceSettings, setMyPosLogo, posSettingsFromWire, type SetMyPosLogoOptions, } from './client.js';
 export { POS_ERROR_CODES, type PosErrorCode, isPosErrorCode, posErrorCode, isPosError, type PosFieldError, posFieldErrors, } from './errors.js';
 export { distributeDiscount } from '../receipt/discount.js';
-export { cancelScopeOf, receiptsScopeOf, type RegisterScope, type RegisterUserPerms } from '../register/pairing.js';
+export { cancelScopeOf, receiptsScopeOf, stockViewOf, type RegisterScope, type RegisterUserPerms } from '../register/pairing.js';
 export { type NetworkPrinter, type PrintJob, type PrintJobStatus, PRINT_JOB_STATUSES, type PrintJobSource, PRINT_JOB_SOURCES, isPrintJobFinished, type CreatePrintJobOptions, listMyPrinters, createPrintJob, getPrintJob, } from './drucker.js';
 export { listMyTipRecipients } from './trinkgeld.js';
+export { STOCK_LOCATION_TYPES, type StockLocationType, type StockLocation, type StockLocationAddress, type StockLevel, type StockValue, type StockList, type ListMyStockOptions, type SetMyCashregisterStockLocationOptions, type CashregisterStockLocation, listMyStockLocations, listMyStock, setMyCashregisterStockLocation, } from './lager.js';
+export { RETURN_DISPOSITIONS, isReturnDisposition, type ReturnDisposition } from '../models/cancellation.js';
 export { MESSAGES, ERROR_RULES, ERROR_CODE_RULES, ERROR_OUTCOME_RULES, CALLS_WITH_EFFECT, findErrorRule, messageOutcome, messageText, messageAppliesTo, RECEIPT_EMAIL_ERROR_MESSAGES, receiptEmailErrorMessage, CANCELLATION_PAYMENT_ERROR_MESSAGES, cancellationPaymentErrorMessage, LABELS, labelText, type TextEntry, type MessageKey, type ErrorKind, type ErrorRule, type ErrorRuleDetail, type Surface, type ReceiptEmailMessageCode, type CancellationPaymentMessageCode, type LabelKey, } from './texte.js';

package/dist/esm/pos/index.js

@@ -1,6 +1,7 @@
 /**
  * Kachel-Kasse: Einstellungen, Artikelgruppen/Artikel fuer Kacheln,
- * Rabattverteilung, Drucker, Trinkgeld-Empfaenger. Die Aufrufe heissen 1:1 wie
+ * Rabattverteilung, Drucker, Trinkgeld-Empfaenger, Lager (Standorte, Bestand,
+ * Standort der Kasse). Die Aufrufe heissen 1:1 wie
  * die Backend-Functions (die Rewrites-Waechter der Web-App leiten daraus ab)
  * und sprechen den Kassenweg `/api/v3` (Schluessel und Werte englisch).
  */
@@ -13,8 +14,11 @@ export { POS_ERROR_CODES, isPosErrorCode, posErrorCode, isPosError, posFieldErro
 export { distributeDiscount } 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 { cancelScopeOf, receiptsScopeOf, stockViewOf } from '../register/pairing.js';
 export { PRINT_JOB_STATUSES, PRINT_JOB_SOURCES, isPrintJobFinished, listMyPrinters, createPrintJob, getPrintJob, } from './drucker.js';
 export { listMyTipRecipients } from './trinkgeld.js';
+export { STOCK_LOCATION_TYPES, listMyStockLocations, listMyStock, setMyCashregisterStockLocation, } from './lager.js';
+// Rueckgabe-Wahl beim Storno (Kassen-Dialog); dieselbe Liste wie an der Wurzel.
+export { RETURN_DISPOSITIONS, isReturnDisposition } from '../models/cancellation.js';
 // Was die Kasse selbst sagt: ein Katalog fuer Browser-Kasse und App.
 export { MESSAGES, ERROR_RULES, ERROR_CODE_RULES, ERROR_OUTCOME_RULES, CALLS_WITH_EFFECT, findErrorRule, messageOutcome, messageText, messageAppliesTo, RECEIPT_EMAIL_ERROR_MESSAGES, receiptEmailErrorMessage, CANCELLATION_PAYMENT_ERROR_MESSAGES, cancellationPaymentErrorMessage, LABELS, labelText, } from './texte.js';

package/dist/esm/pos/lager.d.ts

@@ -0,0 +1,95 @@
+import type { InternerTransport } from '../client/aufrufe.js';
+/**
+ * Lager an der Kasse (Lager-Kern Stufe 2, Backend lager-endpoints.js):
+ * Standorte, Bestand und der Standort der Kasse. Alle drei Aufrufe gibt es
+ * nur ueber den Kassenweg `/api/v3` (registerInternal); Rechte am Server:
+ * `stockView` (lesen), `stockCosts` (Werte), `stockLocation` (Standort setzen).
+ *
+ * **Ganzzahlen:** Mengen sind Tausendstel der Basiseinheit (`1000` = 1 Stueck,
+ * `250` = 0,250 kg), Werte ganze Cent bzw. Mikro-Euro. Nichts wird geteilt,
+ * gerundet oder geklemmt -- ein negativer Bestand (mehr verkauft als gebucht)
+ * ist eine Aussage des Servers und bleibt negativ. Eine Zahl, die keine
+ * Ganzzahl ist, oder eine fehlende Menge wird **nie** zu `0`: der Aufruf
+ * endet mit `KasseneckValidationError` (`scope: 'response'`), denn „kein
+ * Bestand“ und „Antwort kaputt“ sind verschiedene Aussagen.
+ */
+/** Standort-Typen (Katalog `STANDORT_TYP`), englisch wie am Draht. */
+export declare const STOCK_LOCATION_TYPES: readonly ["warehouse", "store", "vehicle", "other"];
+export type StockLocationType = (typeof STOCK_LOCATION_TYPES)[number];
+export interface StockLocationAddress {
+    street: string | null;
+    zip: string | null;
+    city: string | null;
+    country: string | null;
+}
+export interface StockLocation {
+    id: string;
+    name: string;
+    /** `null`: ein Typ, den dieses Paket nicht kennt. */
+    type: StockLocationType | null;
+    /** Fahrzeuge haben keine Adresse. */
+    address: StockLocationAddress | null;
+    /** Kennzeichen, nur bei `vehicle`. */
+    licensePlate: string | null;
+    /** `false` = aufgeloest; als Standort der Kasse abgewiesen (`location_inactive`). */
+    active: boolean;
+    /** `true` = Hauptstandort, den der Server ohne eigenes Dokument ergaenzt. */
+    virtual: boolean;
+}
+/** Bestand eines Artikels an einem Standort, in Tausendstel der Basiseinheit. */
+export interface StockLevel {
+    articleId: string;
+    locationId: string;
+    sellable: number;
+    defective: number;
+    reserved: number;
+    /** `sellable - reserved`, vom Server gerechnet. */
+    available: number;
+}
+/** Lagerwert eines Artikels -- nur mit dem Recht `stockCosts`. */
+export interface StockValue {
+    articleId: string;
+    stockValueCents: number;
+    /** Durchschnittlicher Einstandspreis je Basiseinheit in Mikro-Euro; `null` bei Menge 0. */
+    averageCostMicros: number | null;
+}
+export interface StockList {
+    stock: StockLevel[];
+    /**
+     * `null`, wenn der Aufrufer das Recht `stockCosts` nicht hat (der Server
+     * laesst das Feld weg); `[]`, wenn er es hat und nichts bewertet ist. Eine
+     * Oberflaeche zeigt bei `null` keinen Wert, nie „0,00 €“.
+     */
+    values: StockValue[] | null;
+}
+export interface ListMyStockOptions {
+    /** Nur dieser Standort; `''` gilt wie nicht angegeben. */
+    locationId?: string;
+    /** Nur dieser Artikel; `''` gilt wie nicht angegeben. */
+    articleId?: string;
+    /** Nur Zeilen unter dem Mindestbestand. */
+    belowMinimum?: boolean;
+}
+export interface SetMyCashregisterStockLocationOptions {
+    /** Standort-Kennung; `null` setzt auf den Standard-Standort des Betriebs zurueck. */
+    stockLocationId: string | null;
+    /** Ohne Angabe gilt die Kasse der Anmeldung (`registerUserAuth`). */
+    cashregisterId?: string;
+}
+export interface CashregisterStockLocation {
+    cashregisterId: string;
+    /** `null` = Standard-Standort des Betriebs. */
+    stockLocationId: string | null;
+}
+/** Standorte des Betriebs, samt aufgeloesten (`active: false`) und dem Hauptstandort. */
+export declare function listMyStockLocations(transport: InternerTransport): Promise<StockLocation[]>;
+/** Bestand je Artikel und Standort; Werte nur mit dem Recht `stockCosts`. */
+export declare function listMyStock(transport: InternerTransport, options?: ListMyStockOptions): Promise<StockList>;
+/**
+ * Standort der Kasse setzen -- von dort bucht der Server Verkauf und Storno
+ * ab. `stockLocationId: null` setzt zurueck (am Draht der leere Text).
+ * Fehler am Code: `location_not_found`, `location_inactive`,
+ * `cashregister_not_found`, `cashregister_not_assigned`, `not_permitted`,
+ * `module_inactive`.
+ */
+export declare function setMyCashregisterStockLocation(transport: InternerTransport, options: SetMyCashregisterStockLocationOptions): Promise<CashregisterStockLocation>;

package/dist/esm/pos/lager.js

@@ -0,0 +1,154 @@
+import { KasseneckValidationError } from '../client/errors.js';
+import { liste } from './artikel.js';
+/**
+ * Lager an der Kasse (Lager-Kern Stufe 2, Backend lager-endpoints.js):
+ * Standorte, Bestand und der Standort der Kasse. Alle drei Aufrufe gibt es
+ * nur ueber den Kassenweg `/api/v3` (registerInternal); Rechte am Server:
+ * `stockView` (lesen), `stockCosts` (Werte), `stockLocation` (Standort setzen).
+ *
+ * **Ganzzahlen:** Mengen sind Tausendstel der Basiseinheit (`1000` = 1 Stueck,
+ * `250` = 0,250 kg), Werte ganze Cent bzw. Mikro-Euro. Nichts wird geteilt,
+ * gerundet oder geklemmt -- ein negativer Bestand (mehr verkauft als gebucht)
+ * ist eine Aussage des Servers und bleibt negativ. Eine Zahl, die keine
+ * Ganzzahl ist, oder eine fehlende Menge wird **nie** zu `0`: der Aufruf
+ * endet mit `KasseneckValidationError` (`scope: 'response'`), denn „kein
+ * Bestand“ und „Antwort kaputt“ sind verschiedene Aussagen.
+ */
+/** Standort-Typen (Katalog `STANDORT_TYP`), englisch wie am Draht. */
+export const STOCK_LOCATION_TYPES = Object.freeze(['warehouse', 'store', 'vehicle', 'other']);
+const TYPEN = new Set(STOCK_LOCATION_TYPES);
+function antwortfehler(name, grund) {
+    return new KasseneckValidationError(name, grund, 'response');
+}
+const objekt = (w) => (w !== null && typeof w === 'object' && !Array.isArray(w) ? w : null);
+/** Freitext, der fehlen darf (Name, Adressteile, Kennzeichen): leer = `null`. */
+const textOderNull = (w) => (typeof w === 'string' && w !== '' ? w : null);
+/**
+ * Eine Kennung, die da sein muss: ohne sie ist die Zeile nicht zuzuordnen,
+ * und ein leerer Text als `stockLocationId` setzte die Kasse zurueck.
+ */
+function kennung(name, pfad, w) {
+    if (typeof w !== 'string' || w === '')
+        throw antwortfehler(name, `Antwort enthaelt keine Kennung (data.${pfad} fehlt)`);
+    return w;
+}
+/** Eine Zahl des Servers: Ganzzahl oder Antwortfehler, nie ein Ersatzwert. */
+function ganzzahl(name, pfad, w) {
+    if (typeof w !== 'number' || !Number.isInteger(w)) {
+        throw antwortfehler(name, `Antwort enthaelt keine ganze Zahl (data.${pfad})`);
+    }
+    return w;
+}
+function standort(name, e, i) {
+    const s = objekt(e) ?? {};
+    const pfad = `locations[${i}]`;
+    const a = objekt(s.address);
+    const teile = a ? { street: textOderNull(a.street), zip: textOderNull(a.zip), city: textOderNull(a.city), country: textOderNull(a.country) } : null;
+    // Eine Adresse ohne einen einzigen Teil ist keine Adresse.
+    const address = teile && Object.values(teile).some((t) => t !== null) ? teile : null;
+    return {
+        id: kennung(name, `${pfad}.id`, s.id),
+        name: typeof s.name === 'string' ? s.name : '',
+        type: typeof s.type === 'string' && TYPEN.has(s.type) ? s.type : null,
+        address,
+        licensePlate: textOderNull(s.licensePlate),
+        active: s.active !== false,
+        virtual: s.virtual === true,
+    };
+}
+function bestand(name, e, i) {
+    const b = objekt(e) ?? {};
+    const pfad = `stock[${i}]`;
+    return {
+        articleId: kennung(name, `${pfad}.articleId`, b.articleId),
+        locationId: kennung(name, `${pfad}.locationId`, b.locationId),
+        sellable: ganzzahl(name, `${pfad}.sellable`, b.sellable),
+        defective: ganzzahl(name, `${pfad}.defective`, b.defective),
+        reserved: ganzzahl(name, `${pfad}.reserved`, b.reserved),
+        available: ganzzahl(name, `${pfad}.available`, b.available),
+    };
+}
+function wert(name, e, i) {
+    const w = objekt(e) ?? {};
+    const pfad = `values[${i}]`;
+    return {
+        articleId: kennung(name, `${pfad}.articleId`, w.articleId),
+        stockValueCents: ganzzahl(name, `${pfad}.stockValueCents`, w.stockValueCents),
+        // Fehlt der Durchschnitt oder ist er null, ist die Menge 0 -- eine
+        // vorhandene, aber unbrauchbare Zahl ist dagegen ein Antwortfehler.
+        averageCostMicros: w.averageCostMicros === undefined || w.averageCostMicros === null
+            ? null
+            : ganzzahl(name, `${pfad}.averageCostMicros`, w.averageCostMicros),
+    };
+}
+/** Standorte des Betriebs, samt aufgeloesten (`active: false`) und dem Hauptstandort. */
+export async function listMyStockLocations(transport) {
+    const name = 'listMyStockLocations';
+    const daten = await transport(name);
+    return liste(daten, 'locations', name, (e, i) => standort(name, e, i));
+}
+/** Bestand je Artikel und Standort; Werte nur mit dem Recht `stockCosts`. */
+export async function listMyStock(transport, options = {}) {
+    const name = 'listMyStock';
+    if (options === null || typeof options !== 'object')
+        throw new KasseneckValidationError(name, 'options muss ein Objekt sein', 'request');
+    const params = {};
+    for (const feld of ['locationId', 'articleId']) {
+        const w = options[feld];
+        if (w === undefined || w === '')
+            continue;
+        if (typeof w !== 'string')
+            throw new KasseneckValidationError(name, `${feld} muss Text sein`, 'request');
+        params[feld] = w;
+    }
+    if (options.belowMinimum !== undefined) {
+        if (typeof options.belowMinimum !== 'boolean')
+            throw new KasseneckValidationError(name, 'belowMinimum muss true oder false sein', 'request');
+        // false filtert am Server nicht; gesendet wird nur der Filter selbst.
+        if (options.belowMinimum)
+            params.belowMinimum = true;
+    }
+    const daten = await transport(name, params);
+    const stock = liste(daten, 'stock', name, (e, i) => bestand(name, e, i));
+    const roh = objekt(daten)?.values;
+    // Fehlt `values`, fehlt dem Aufrufer das Recht `stockCosts`: `null`, nie `[]`.
+    // Etwas anderes als eine Liste ist dagegen kein „kein Recht“, sondern kaputt.
+    if (roh === undefined || roh === null)
+        return { stock, values: null };
+    return { stock, values: liste(daten, 'values', name, (e, i) => wert(name, e, i)) };
+}
+/**
+ * Standort der Kasse setzen -- von dort bucht der Server Verkauf und Storno
+ * ab. `stockLocationId: null` setzt zurueck (am Draht der leere Text).
+ * Fehler am Code: `location_not_found`, `location_inactive`,
+ * `cashregister_not_found`, `cashregister_not_assigned`, `not_permitted`,
+ * `module_inactive`.
+ */
+export async function setMyCashregisterStockLocation(transport, options) {
+    const name = 'setMyCashregisterStockLocation';
+    const ziel = options?.stockLocationId;
+    if (ziel !== null && typeof ziel !== 'string') {
+        throw new KasseneckValidationError(name, 'stockLocationId fehlt (Kennung, oder null zum Zuruecksetzen)', 'request');
+    }
+    // Leer setzt zurueck. Nur Leerraum wuerde der Server kuerzen und damit still
+    // auf den Standard-Standort zuruecksetzen: das ist kein Standort, sondern ein Fehler.
+    if (ziel !== null && ziel !== '' && ziel.trim() === '') {
+        throw new KasseneckValidationError(name, 'stockLocationId ist nur Leerraum (Kennung angeben, oder null zum Zuruecksetzen)', 'request');
+    }
+    const params = { stockLocationId: ziel === null ? '' : ziel };
+    if (options.cashregisterId !== undefined) {
+        if (typeof options.cashregisterId !== 'string' || options.cashregisterId.trim() === '') {
+            throw new KasseneckValidationError(name, 'cashregisterId ist leer', 'request');
+        }
+        params.cashregisterId = options.cashregisterId;
+    }
+    const daten = objekt(await transport(name, params));
+    if (!daten || typeof daten.cashregisterId !== 'string' || daten.cashregisterId === '') {
+        throw antwortfehler(name, 'Antwort enthaelt keine Kasse (data.cashregisterId fehlt)');
+    }
+    const stand = daten.stockLocationId;
+    if (stand !== null && stand !== undefined && typeof stand !== 'string') {
+        throw antwortfehler(name, 'Antwort enthaelt einen unbrauchbaren Standort (data.stockLocationId)');
+    }
+    return { cashregisterId: daten.cashregisterId, stockLocationId: textOderNull(stand) };
+}

package/dist/esm/register/errors.d.ts

@@ -22,7 +22,7 @@ import { KasseneckApiError } from '../client/errors.js';
  * ueber `KasseneckApiError.code` lesbar; die Kasse braucht dafuer einen
  * Rueckfallzweig.
  */
-export declare const REGISTER_ERROR_CODES: readonly ["account_not_found", "admin_required", "cashregister_in_use", "cashregister_not_assigned", "cashregister_not_found", "cashregister_token_invalid", "cashregister_token_missing", "device_bound_elsewhere", "device_not_found", "device_not_paired", "device_takeover_required", "dialect_mismatch", "internal_translation_error", "licenses_exhausted", "live_not_enabled", "location_outside", "location_required", "login_failed", "login_mode_select_user", "login_unavailable", "method_not_allowed", "mfa_required", "not_found", "pairing_code_expired", "pairing_code_unknown", "pairing_code_used", "pairing_failed", "register_user_no_business", "register_user_not_allowed", "register_user_not_found", "register_user_only", "response_translation_failed", "session_ended", "session_expired", "session_not_running", "session_other_cashregister", "too_many_attempts", "unauthorized", "user_disabled", "user_verification_failed", "validation", "route_missing"];
+export declare const REGISTER_ERROR_CODES: readonly ["account_not_found", "admin_required", "api_not_approved", "cashregister_in_use", "cashregister_not_assigned", "cashregister_not_found", "cashregister_token_invalid", "cashregister_token_missing", "device_bound_elsewhere", "device_not_found", "device_not_paired", "device_takeover_required", "dialect_mismatch", "internal_translation_error", "licenses_exhausted", "live_not_enabled", "location_outside", "location_required", "login_failed", "login_mode_select_user", "login_unavailable", "method_not_allowed", "mfa_required", "not_found", "pairing_code_expired", "pairing_code_unknown", "pairing_code_used", "pairing_failed", "register_user_no_business", "register_user_not_allowed", "register_user_not_found", "register_user_only", "response_translation_failed", "session_ended", "session_expired", "session_not_running", "session_other_cashregister", "too_many_attempts", "unauthorized", "user_disabled", "user_verification_failed", "validation", "route_missing"];
 export type RegisterErrorCode = typeof REGISTER_ERROR_CODES[number];
 export declare function isRegisterErrorCode(value: unknown): value is RegisterErrorCode;
 /** Der Code eines geworfenen Fehlers, wenn es einer der Kassen-Anmeldung ist; sonst `undefined`. */

package/dist/esm/register/errors.js

@@ -26,6 +26,7 @@ import { feldfehlerVon } from '../client/fehlercodes.js';
 export const REGISTER_ERROR_CODES = Object.freeze([
     'account_not_found',
     'admin_required',
+    'api_not_approved',
     'cashregister_in_use',
     'cashregister_not_assigned',
     'cashregister_not_found',

package/dist/esm/register/pairing.d.ts

@@ -137,10 +137,12 @@ export interface RegisterDeviceUsers {
      * nennt den Grund als Menschentext (ausser Betrieb, keine Signaturkarte,
      * Startbeleg fehlt): die Kasse sperrt das Kassieren VOR dem ersten Beleg
      * statt an createReceipt zu scheitern. Fehlt das Feld, gilt bereit.
+     * `stockLocationId`: Lager-Standort der Kasse, fehlt = Standard-Standort.
      */
     cashregister?: {
         ready: boolean;
         reason?: string | null;
+        stockLocationId?: string;
     };
     /** Das Geraet haengt an der Test-Umgebung des Betriebs. */
     testEnvironment: boolean;
@@ -179,6 +181,24 @@ export interface RegisterUserPerms {
     discount?: boolean;
     /** Trinkgeld anderen zuweisen. */
     tipAssign?: boolean;
+    /**
+     * Lager: Standorte und Mengen sehen (listMyStockLocations, listMyStock).
+     * Fehlt das Recht, gilt es als erteilt – anders als alle anderen
+     * (siehe [stockViewOf]); ein ausdrueckliches `false` sperrt.
+     */
+    stockView?: boolean;
+    /** Lager: Einkaufswerte sehen (`values` in listMyStock); gibt nur der Inhaber frei. */
+    stockCosts?: boolean;
+    /** Lager: Wareneingang, Umbuchen. */
+    stockMove?: boolean;
+    /** Lager: Abgang, Zustand, Gegenbuchung. */
+    stockLoss?: boolean;
+    /** Inventur: zaehlen. */
+    stocktakeCount?: boolean;
+    /** Inventur: abschliessen. */
+    stocktakeClose?: boolean;
+    /** Standort der Kasse waehlen (setMyCashregisterStockLocation). */
+    stockLocation?: boolean;
     [weiteresRecht: string]: boolean | RegisterScope | undefined;
 }
 /**
@@ -189,10 +209,16 @@ export interface RegisterUserPerms {
  * nicht fuehrt (Tippfehler, umbenanntes Recht), kommt hier nicht durch.
  * Die Gegenrichtung schliesst [_RechteVollstaendig] direkt darunter.
  */
-export declare const REGISTER_PERMS: readonly ["sell", "cancel", "articles", "layout", "reports", "takeover", "cancelScope", "receiptsScope", "drawer", "discount", "tipAssign"];
+export declare const REGISTER_PERMS: readonly ["sell", "cancel", "articles", "layout", "reports", "takeover", "cancelScope", "receiptsScope", "drawer", "discount", "tipAssign", "stockView", "stockCosts", "stockMove", "stockLoss", "stocktakeCount", "stocktakeClose", "stockLocation"];
 /** Reichweite lesen, mit der Migration des Backends (register-auth.js). */
 export declare function cancelScopeOf(perms: RegisterUserPerms | null | undefined): RegisterScope;
 export declare function receiptsScopeOf(perms: RegisterUserPerms | null | undefined): RegisterScope;
+/**
+ * Darf der Benutzer Standorte und Mengen sehen? Wie im Backend (lager-core):
+ * ohne Schluessel gilt `stockView` als erteilt, ein ausdrueckliches `false`
+ * sperrt; alle anderen Lager-Rechte gelten ohne Schluessel als verweigert.
+ */
+export declare function stockViewOf(perms: RegisterUserPerms | null | undefined): boolean;
 /** Der angemeldete Kassen-Benutzer. */
 export interface RegisterUser {
     id: string;

package/dist/esm/register/pairing.js

@@ -49,6 +49,7 @@ const ohneAnmeldung = () => ({ headers: {}, params: {} });
 export const REGISTER_PERMS = [
     'sell', 'cancel', 'articles', 'layout', 'reports', 'takeover',
     'cancelScope', 'receiptsScope', 'drawer', 'discount', 'tipAssign',
+    'stockView', 'stockCosts', 'stockMove', 'stockLoss', 'stocktakeCount', 'stocktakeClose', 'stockLocation',
 ];
 /** Reichweite lesen, mit der Migration des Backends (register-auth.js). */
 export function cancelScopeOf(perms) {
@@ -65,6 +66,16 @@ export function receiptsScopeOf(perms) {
         return 'all';
     return ['none', 'own', 'all'].includes(perms.receiptsScope) ? perms.receiptsScope : 'none';
 }
+/**
+ * Darf der Benutzer Standorte und Mengen sehen? Wie im Backend (lager-core):
+ * ohne Schluessel gilt `stockView` als erteilt, ein ausdrueckliches `false`
+ * sperrt; alle anderen Lager-Rechte gelten ohne Schluessel als verweigert.
+ */
+export function stockViewOf(perms) {
+    if (!perms)
+        return false;
+    return perms.stockView === undefined ? true : perms.stockView === true;
+}
 /**
  * Geraet koppeln: der Kopplungs-Code wird gegen den dauerhaften Ausweis dieses
  * Geraets getauscht. **Ohne Anmeldung** — der Code ist der Nachweis.
@@ -199,7 +210,12 @@ function kasseBereit(wert) {
     const roh = wert;
     if (typeof roh['ready'] !== 'boolean')
         return undefined;
-    return { ready: roh['ready'], reason: typeof roh['reason'] === 'string' ? roh['reason'] : null };
+    const standort = roh['stockLocationId'];
+    return {
+        ready: roh['ready'],
+        reason: typeof roh['reason'] === 'string' ? roh['reason'] : null,
+        ...(typeof standort === 'string' && standort !== '' ? { stockLocationId: standort } : {}),
+    };
 }
 /** Die Regel aus der Antwort — oder `null`, wenn keine brauchbare kommt. */
 function regel(wert) {