@kreiseck/kasseneck-api 1.4.0 → 1.5.1

package/dist/cjs/inventory/lesen.js

@@ -25,6 +25,10 @@ exports.zustellung = zustellung;
 exports.probeZustellung = probeZustellung;
 exports.bestandGeaendert = bestandGeaendert;
 exports.unterMindestbestand = unterMindestbestand;
+exports.vorgang = vorgang;
+exports.vorschauZeile = vorschauZeile;
+exports.reservierung = reservierung;
+exports.fehlmengen = fehlmengen;
 exports.liste = liste;
 exports.naechsterCursor = naechsterCursor;
 const errors_js_1 = require("../client/errors.js");
@@ -75,6 +79,30 @@ function textAbbildung(w) {
             raus[k] = v;
     return raus;
 }
+/**
+ * Mengen je Standort (`minStockByLocation`): jeder Wert eine Ganzzahl. Fehlt
+ * das Feld (Server vor Stufe 5b), gilt „keiner“ (`{}`).
+ */
+function mengenJeStandort(ort, feld, w) {
+    if (w === undefined || w === null)
+        return {};
+    const o = objekt(w);
+    if (!o)
+        throw antwortfehler(ort.name, `Antwort ist unbrauchbar (data.${ort.pfad}.${feld} ist kein Objekt)`);
+    const raus = {};
+    for (const [k, v] of Object.entries(o))
+        raus[k] = ganzzahl(ort, `${feld}.${k}`, v);
+    return raus;
+}
+/** Eine Liste von Kennungen (`movementIds`, `lotIds`); fehlt sie, ist sie leer. */
+function kennungsliste(ort, feld, w) {
+    if (w === undefined || w === null)
+        return [];
+    if (!Array.isArray(w) || !w.every((x) => typeof x === 'string')) {
+        throw antwortfehler(ort.name, `Antwort ist unbrauchbar (data.${ort.pfad}${ort.pfad ? '.' : ''}${feld} ist keine Liste von Kennungen)`);
+    }
+    return [...w];
+}
 // ---- Artikel ------------------------------------------------------------------
 function artikel(ort, w) {
     const a = eintrag(ort, w);
@@ -92,6 +120,7 @@ function artikel(ort, w) {
     const raus = {
         id: kennung(ort, 'id', a.id),
         name: text(a.name),
+        description: text(a.description),
         unitPriceCents: ganzzahlOderNull(ort, 'unitPriceCents', a.unitPriceCents),
         vatRate: typeof vatRate === 'number' ? vatRate : null,
         unit: text(a.unit),
@@ -101,8 +130,10 @@ function artikel(ort, w) {
         groupId: text(a.groupId),
         revenueGroupId: text(a.revenueGroupId),
         stockTracked: a.stockTracked === true,
+        stockKind: textOderNull(a.stockKind),
         stockLocationIds: standorte,
         minStock: ganzzahlOderNull(ort, 'minStock', a.minStock),
+        minStockByLocation: mengenJeStandort(ort, 'minStockByLocation', a.minStockByLocation),
         active: a.active !== false,
         createdAt: text(a.createdAt),
         updatedAt: text(a.updatedAt),
@@ -189,8 +220,14 @@ function bewegung(ort, w) {
         locationId: text(b.locationId),
         condition: text(b.condition),
         quantityDelta: ganzzahl(ort, 'quantityDelta', b.quantityDelta),
+        // Server vor Stufe 5b senden das Feld nicht: dort aenderte keine Bewegung `reserved`.
+        reservedDelta: b.reservedDelta === undefined ? 0 : ganzzahl(ort, 'reservedDelta', b.reservedDelta),
         stockAfter: nachher
-            ? { sellable: ganzzahl(nachherOrt, 'sellable', nachher.sellable), defective: ganzzahl(nachherOrt, 'defective', nachher.defective) }
+            ? {
+                sellable: ganzzahl(nachherOrt, 'sellable', nachher.sellable),
+                defective: ganzzahl(nachherOrt, 'defective', nachher.defective),
+                reserved: ganzzahlOderNull(nachherOrt, 'reserved', nachher.reserved),
+            }
             : null,
         operationId: text(b.operationId),
         source: quelle
@@ -271,6 +308,99 @@ function unterMindestbestand(ort, w) {
         minStock: ganzzahl(ort, 'minStock', d.minStock),
     };
 }
+// ---- Schreiben (Stufe 5b) ------------------------------------------------------------
+function warnung(ort, w) {
+    const h = eintrag(ort, w);
+    if (typeof h.code !== 'string' || h.code === '')
+        throw antwortfehler(ort.name, `Hinweis ohne Code (data.${ort.pfad}.code)`);
+    return {
+        code: h.code,
+        articleId: textOderNull(h.articleId),
+        locationId: textOderNull(h.locationId),
+        message: typeof h.message === 'string' ? h.message : '',
+    };
+}
+/** Antwort einer Buchung; ohne `operationId` ist nicht belegt, dass gebucht wurde. */
+function vorgang(name, daten) {
+    const d = objekt(daten);
+    if (!d)
+        throw antwortfehler(name, 'Antwort ist unbrauchbar (data ist kein Objekt)');
+    const ort = { name, pfad: '' };
+    if (typeof d.operationId !== 'string' || d.operationId === '') {
+        throw antwortfehler(name, 'Antwort enthaelt keine Kennung (data.operationId fehlt)');
+    }
+    const hinweise = d.warnings === undefined || d.warnings === null ? [] : d.warnings;
+    if (!Array.isArray(hinweise))
+        throw antwortfehler(name, 'Antwort ist unbrauchbar (data.warnings ist keine Liste)');
+    return {
+        operationId: d.operationId,
+        movementIds: kennungsliste(ort, 'movementIds', d.movementIds),
+        lotIds: kennungsliste(ort, 'lotIds', d.lotIds),
+        warnings: hinweise.map((h, i) => warnung({ name, pfad: `warnings[${i}]` }, h)),
+    };
+}
+/** Eine Zeile der Wareneingangs-Vorschau; Werte nur, wenn der Server sie sendet (Recht `costs`). */
+function vorschauZeile(ort, w) {
+    const z = eintrag(ort, w);
+    const serien = z.serialNumbers === undefined || z.serialNumbers === null ? [] : z.serialNumbers;
+    if (!Array.isArray(serien) || !serien.every((x) => typeof x === 'string')) {
+        throw antwortfehler(ort.name, `Antwort ist unbrauchbar (data.${ort.pfad}.serialNumbers ist keine Liste)`);
+    }
+    const raus = {
+        articleId: kennung(ort, 'articleId', z.articleId),
+        quantity: ganzzahl(ort, 'quantity', z.quantity),
+        expiresOn: textOderNull(z.expiresOn),
+        batch: textOderNull(z.batch),
+        serialNumbers: [...serien],
+        priceFromArticle: z.priceFromArticle === true,
+    };
+    for (const feld of ['baseCents', 'landedCostCents', 'valueCents', 'unitCostMicros']) {
+        if (hat(z, feld))
+            raus[feld] = ganzzahlOderNull(ort, feld, z[feld]);
+    }
+    return raus;
+}
+function reservierungsPosition(ort, w) {
+    const p = eintrag(ort, w);
+    return {
+        articleId: kennung(ort, 'articleId', p.articleId),
+        locationId: kennung(ort, 'locationId', p.locationId),
+        quantity: ganzzahl(ort, 'quantity', p.quantity),
+        redeemed: ganzzahl(ort, 'redeemed', p.redeemed),
+        released: ganzzahl(ort, 'released', p.released),
+    };
+}
+function reservierung(ort, w) {
+    const r = eintrag(ort, w);
+    if (!Array.isArray(r.items))
+        throw antwortfehler(ort.name, `Antwort ist unbrauchbar (data.${ort.pfad}.items ist keine Liste)`);
+    return {
+        id: kennung(ort, 'id', r.id),
+        status: textOderNull(r.status),
+        reference: text(r.reference),
+        items: r.items.map((p, i) => reservierungsPosition({ name: ort.name, pfad: `${ort.pfad}.items[${i}]` }, p)),
+        expiresAt: text(r.expiresAt),
+        createdAt: text(r.createdAt),
+    };
+}
+/** Die fehlenden Positionen aus `insufficient_available` (`data.details[]`); ein kaputter Eintrag faellt weg. */
+function fehlmengen(roh) {
+    if (!Array.isArray(roh))
+        return [];
+    const raus = [];
+    for (const e of roh) {
+        const o = objekt(e);
+        if (!o)
+            continue;
+        const { articleId, locationId, requested, available } = o;
+        if (typeof articleId !== 'string' || typeof locationId !== 'string')
+            continue;
+        if (!Number.isSafeInteger(requested) || !Number.isSafeInteger(available))
+            continue;
+        raus.push({ articleId, locationId, requested: requested, available: available });
+    }
+    return raus;
+}
 // ---- Listen ------------------------------------------------------------------
 /** Eine zugesagte Liste `data.<feld>`, Eintrag fuer Eintrag gelesen. */
 function liste(name, daten, feld, lesen) {

package/dist/cjs/inventory/schreiben.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Die schreibenden Aufrufe der Lager-API (Backend Stufe 5b): Artikel anlegen,
+ * aendern und stilllegen, Bestand buchen (Wareneingang, Umbuchung, Abgang,
+ * Zustand, Gegenbuchung) und reservieren.
+ *
+ * Wie in `endpunkte.ts` nimmt jede Funktion den Transport als ersten Parameter
+ * und ist einzeln importierbar. Die Anfrage geht flach hinaus, genau mit den
+ * Feldern, die der Aufrufer nennt (`undefined` faellt weg, `null` bleibt: es
+ * leert ein Feld bzw. heisst bei der Anlage „nicht angegeben“).
+ *
+ * **Vor dem Senden geprueft wird nur, was ohne Netz sicher falsch ist:**
+ * - `idempotencyKey` fehlt, ist leer oder laenger als 120 Zeichen. Ohne
+ *   Schluessel gaebe es keine sichere Wiederholung, und der Server wiese die
+ *   Anfrage ohnehin ab (`idempotency_key_required` bzw. `validation`);
+ * - eine Pflichtkennung fehlt oder ist leer;
+ * - eine Menge, ein Betrag oder ein Preis ist keine Ganzzahl (Tausendstel,
+ *   Cent, Mikro-Euro): `1.5` waere nie „1,5 Stueck“, sondern ein Fehler;
+ * - `expiresInMinutes` liegt ausserhalb 5 … 43 200;
+ * - eine Aenderung nennt kein Feld, eine Freigabe eine leere Liste.
+ * Alles Fachliche (Pruefziffer der EAN, Kataloge, Bestand, Rechte) prueft der
+ * Server und meldet es mit seinem Code.
+ *
+ * **Wiederholen:** nach einem Zeitlimit oder Netzfehler denselben Aufruf mit
+ * **demselben** `idempotencyKey` noch einmal senden. Er wirkt genau einmal und
+ * liefert die gespeicherte Antwort; ein neuer Schluessel buchte ein zweites Mal.
+ * Darum meldet jeder schreibende Aufruf in diesen Faellen (auch HTTP 5xx und
+ * unlesbare Antwort) `outcome: 'unknown'`, nie `'rejected'`. Lesen und der
+ * Probelauf (`previewGoodsReceipt`) bleiben `'rejected'`.
+ */
+import type { InternerTransport } from '../client/aufrufe.js';
+import type { Article, ChangeStockConditionRequest, CreateArticleRequest, CreateReservationRequest, DeactivateArticleRequest, ExtendReservationRequest, GoodsReceiptPreview, GoodsReceiptPreviewRequest, ReceiveGoodsRequest, RecordStockLossRequest, ReleaseReservationRequest, Reservation, ReservationListQuery, ReservationPage, ReverseStockMovementRequest, StockOperation, TransferStockRequest, UpdateArticleRequest } from './typen.js';
+/**
+ * Legt einen Artikel an. Mit `ean` ein Fremdartikel mit diesem Code (gueltige
+ * Pruefziffer, frei im Konto), sonst vergibt der Server den naechsten eigenen
+ * Code. Antwort: der Artikel wie `getArticle`.
+ */
+export declare function createArticle(transport: InternerTransport, request: CreateArticleRequest): Promise<Article>;
+/** Aendert nur die genannten Felder eines Artikels (siehe [UpdateArticleRequest]). */
+export declare function updateArticle(transport: InternerTransport, request: UpdateArticleRequest): Promise<Article>;
+/** Legt einen Artikel still (`active: false`); Code und eigene Kennungen werden frei. */
+export declare function deactivateArticle(transport: InternerTransport, request: DeactivateArticleRequest): Promise<Article>;
+/**
+ * Bucht einen Wareneingang. Ohne `locationId` am Standard-Standort; die
+ * Antwort traegt keine Werte, auch mit dem Recht `costs` nicht. Fuer die
+ * Vorschau mit Werten: [previewGoodsReceipt].
+ */
+export declare function receiveGoods(transport: InternerTransport, request: ReceiveGoodsRequest): Promise<StockOperation>;
+/**
+ * Vorschau eines Wareneingangs (`receiveGoods` mit `dryRun: true`): prueft
+ * Positionen, Artikel, Preise und Nebenkosten und rechnet die Verteilung,
+ * schreibt aber nichts. Ein `idempotencyKey` ist freigestellt (`null` wie nicht
+ * angegeben, geht nicht hinaus) und wird nicht verbraucht; dieselbe Anfrage
+ * laesst sich danach mit ihm buchen. Werte
+ * (`baseCents` …) nur mit dem Recht `costs`. Den Standort prueft erst die Buchung.
+ */
+export declare function previewGoodsReceipt(transport: InternerTransport, request: GoodsReceiptPreviewRequest): Promise<GoodsReceiptPreview>;
+/** Bucht Ware von einem Standort an einen anderen; ueberzieht nie (`exceeds_stock`). */
+export declare function transferStock(transport: InternerTransport, request: TransferStockRequest): Promise<StockOperation>;
+/** Bucht einen Abgang (Bruch, Schwund, Diebstahl, Entnahme …); ueberzieht nie (`exceeds_stock`). */
+export declare function recordStockLoss(transport: InternerTransport, request: RecordStockLossRequest): Promise<StockOperation>;
+/** Bucht Ware zwischen `sellable` und `defective` um; ueberzieht nie (`exceeds_stock`). */
+export declare function changeStockCondition(transport: InternerTransport, request: ChangeStockConditionRequest): Promise<StockOperation>;
+/** Nimmt einen ganzen Vorgang (`operationId`) mit einer Gegenbuchung zurueck. */
+export declare function reverseStockMovement(transport: InternerTransport, request: ReverseStockMovementRequest): Promise<StockOperation>;
+/**
+ * Reserviert Ware (Checkout im Shop): ganz oder gar nicht, gemessen am
+ * verfuegbaren Bestand (`onHand − reserved`). Fehlt etwas, entsteht nichts:
+ * `insufficient_available`, die fehlenden Positionen in [inventoryShortfalls].
+ * Eingeloest wird ueber eine Rechnung (`issueInvoice` mit `items[].reservationId`),
+ * sonst laeuft die Reservierung ab und gibt die Ware wieder frei.
+ */
+export declare function createReservation(transport: InternerTransport, request: CreateReservationRequest): Promise<Reservation>;
+/** Verlaengert eine aktive Reservierung: neuer Ablauf = jetzt + `expiresInMinutes`. */
+export declare function extendReservation(transport: InternerTransport, request: ExtendReservationRequest): Promise<Reservation>;
+/**
+ * Gibt reservierte Ware frei: ohne `items` alles, sonst je Position (ohne
+ * `quantity` der ganze offene Rest). Die Antwort traegt den Stand danach;
+ * `released` wird der Status erst, wenn nichts mehr offen ist.
+ */
+export declare function releaseReservation(transport: InternerTransport, request: ReleaseReservationRequest): Promise<Reservation>;
+/** Eine Reservierung mit ihrem aktuellen Stand. */
+export declare function getReservation(transport: InternerTransport, reservationId: string): Promise<Reservation>;
+/** Reservierungen, neueste zuerst; Filter `status` und/oder `reference`. */
+export declare function listReservations(transport: InternerTransport, query?: ReservationListQuery): Promise<ReservationPage>;
+/** Alle Reservierungen der Abfrage, Seite fuer Seite ueber `nextCursor`. */
+export declare function iterateReservations(transport: InternerTransport, query?: ReservationListQuery): AsyncGenerator<Reservation, void, undefined>;

package/dist/cjs/inventory/schreiben.js

@@ -0,0 +1,320 @@
+"use strict";
+/**
+ * Die schreibenden Aufrufe der Lager-API (Backend Stufe 5b): Artikel anlegen,
+ * aendern und stilllegen, Bestand buchen (Wareneingang, Umbuchung, Abgang,
+ * Zustand, Gegenbuchung) und reservieren.
+ *
+ * Wie in `endpunkte.ts` nimmt jede Funktion den Transport als ersten Parameter
+ * und ist einzeln importierbar. Die Anfrage geht flach hinaus, genau mit den
+ * Feldern, die der Aufrufer nennt (`undefined` faellt weg, `null` bleibt: es
+ * leert ein Feld bzw. heisst bei der Anlage „nicht angegeben“).
+ *
+ * **Vor dem Senden geprueft wird nur, was ohne Netz sicher falsch ist:**
+ * - `idempotencyKey` fehlt, ist leer oder laenger als 120 Zeichen. Ohne
+ *   Schluessel gaebe es keine sichere Wiederholung, und der Server wiese die
+ *   Anfrage ohnehin ab (`idempotency_key_required` bzw. `validation`);
+ * - eine Pflichtkennung fehlt oder ist leer;
+ * - eine Menge, ein Betrag oder ein Preis ist keine Ganzzahl (Tausendstel,
+ *   Cent, Mikro-Euro): `1.5` waere nie „1,5 Stueck“, sondern ein Fehler;
+ * - `expiresInMinutes` liegt ausserhalb 5 … 43 200;
+ * - eine Aenderung nennt kein Feld, eine Freigabe eine leere Liste.
+ * Alles Fachliche (Pruefziffer der EAN, Kataloge, Bestand, Rechte) prueft der
+ * Server und meldet es mit seinem Code.
+ *
+ * **Wiederholen:** nach einem Zeitlimit oder Netzfehler denselben Aufruf mit
+ * **demselben** `idempotencyKey` noch einmal senden. Er wirkt genau einmal und
+ * liefert die gespeicherte Antwort; ein neuer Schluessel buchte ein zweites Mal.
+ * Darum meldet jeder schreibende Aufruf in diesen Faellen (auch HTTP 5xx und
+ * unlesbare Antwort) `outcome: 'unknown'`, nie `'rejected'`. Lesen und der
+ * Probelauf (`previewGoodsReceipt`) bleiben `'rejected'`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createArticle = createArticle;
+exports.updateArticle = updateArticle;
+exports.deactivateArticle = deactivateArticle;
+exports.receiveGoods = receiveGoods;
+exports.previewGoodsReceipt = previewGoodsReceipt;
+exports.transferStock = transferStock;
+exports.recordStockLoss = recordStockLoss;
+exports.changeStockCondition = changeStockCondition;
+exports.reverseStockMovement = reverseStockMovement;
+exports.createReservation = createReservation;
+exports.extendReservation = extendReservation;
+exports.releaseReservation = releaseReservation;
+exports.getReservation = getReservation;
+exports.listReservations = listReservations;
+exports.iterateReservations = iterateReservations;
+const endpunkte_js_1 = require("./endpunkte.js");
+const lesen_js_1 = require("./lesen.js");
+const vertrag_js_1 = require("./vertrag.js");
+// ---- Pruefung vor dem Senden ------------------------------------------------------
+/** Die Anfrage als flache Kopie ohne `undefined`; der Aufrufer behaelt sein Objekt. */
+function anfrage(name, request) {
+    if (request === null || typeof request !== 'object' || Array.isArray(request)) {
+        throw (0, endpunkte_js_1.anfragefehler)(name, 'Anfrage muss ein Objekt sein');
+    }
+    const raus = {};
+    for (const [feld, w] of Object.entries(request))
+        if (w !== undefined)
+            raus[feld] = w;
+    return raus;
+}
+/**
+ * `idempotencyKey`: Text mit 1–120 Zeichen, nicht nur Leerraum. Er wird nie
+ * getrimmt oder gekuerzt: ein veraenderter Schluessel waere ein anderer.
+ */
+function schluessel(name, p, { pflicht }) {
+    const w = p.idempotencyKey;
+    if (w === undefined || w === null) {
+        if (pflicht) {
+            throw (0, endpunkte_js_1.anfragefehler)(name, 'idempotencyKey fehlt (Pflicht bei jedem Schreiben); bei einer Wiederholung denselben Schluessel senden');
+        }
+        return;
+    }
+    if (typeof w !== 'string' || w.trim() === '')
+        throw (0, endpunkte_js_1.anfragefehler)(name, 'idempotencyKey muss ein nicht leerer Text sein');
+    if (w.length > vertrag_js_1.INVENTORY_IDEMPOTENCY_KEY_MAX) {
+        throw (0, endpunkte_js_1.anfragefehler)(name, `idempotencyKey ist laenger als ${vertrag_js_1.INVENTORY_IDEMPOTENCY_KEY_MAX} Zeichen`);
+    }
+}
+/** Eine Ganzzahl (Tausendstel, Cent, Mikro-Euro); fehlt sie, nur wenn sie darf. `null` nur, wo es leert. */
+function ganz(name, feld, w, { pflicht = false, leerbar = false } = {}) {
+    if (w === undefined || (w === null && leerbar)) {
+        if (pflicht)
+            throw (0, endpunkte_js_1.anfragefehler)(name, `${feld} fehlt`);
+        return;
+    }
+    if (typeof w !== 'number' || !Number.isSafeInteger(w)) {
+        throw (0, endpunkte_js_1.anfragefehler)(name, `${feld} muss eine ganze Zahl sein (Mengen in Tausendstel, Geld in Cent, Preise in Mikro-Euro)`);
+    }
+}
+/** Haltedauer einer Reservierung in ganzen Minuten. */
+function minuten(name, w, { pflicht }) {
+    if (w === undefined || (w === null && !pflicht)) {
+        if (pflicht)
+            throw (0, endpunkte_js_1.anfragefehler)(name, 'expiresInMinutes fehlt');
+        return;
+    }
+    if (typeof w !== 'number' || !Number.isSafeInteger(w) || w < vertrag_js_1.RESERVATION_MINUTES_MIN || w > vertrag_js_1.RESERVATION_MINUTES_MAX) {
+        throw (0, endpunkte_js_1.anfragefehler)(name, `expiresInMinutes muss eine ganze Zahl von ${vertrag_js_1.RESERVATION_MINUTES_MIN} bis ${vertrag_js_1.RESERVATION_MINUTES_MAX} sein`);
+    }
+}
+/**
+ * Positionen: eine Liste (Pflicht, wo der Aufruf sie verlangt), jede ein
+ * Objekt mit `articleId` und ganzzahliger `quantity`. `weiter` prueft die
+ * uebrigen Zahlenfelder einer Position. Leer und zu lang entscheidet der Server
+ * (`no_positions`, `too_many_positions`).
+ */
+function positionen(name, w, { pflicht, menge }, weiter = () => { }) {
+    if (w === undefined) {
+        if (pflicht)
+            throw (0, endpunkte_js_1.anfragefehler)(name, 'items fehlt');
+        return;
+    }
+    if (!Array.isArray(w))
+        throw (0, endpunkte_js_1.anfragefehler)(name, 'items muss eine Liste sein');
+    w.forEach((x, i) => {
+        const f = `items[${i}]`;
+        if (x === null || typeof x !== 'object' || Array.isArray(x))
+            throw (0, endpunkte_js_1.anfragefehler)(name, `${f} muss ein Objekt sein`);
+        const o = x;
+        (0, endpunkte_js_1.kennung)(name, `${f}.articleId`, o.articleId);
+        ganz(name, `${f}.quantity`, o.quantity, { pflicht: menge === 'pflicht' });
+        weiter(o, f);
+    });
+}
+// ---- Artikel ------------------------------------------------------------------
+/** Zahlenfelder eines Artikels; `null` leert sie (bzw. heisst bei der Anlage „nicht angegeben“). */
+function artikelZahlen(name, p) {
+    for (const feld of ['unitPriceCents', 'minStock', 'purchasePriceMicros'])
+        ganz(name, feld, p[feld], { leerbar: true });
+    const jeStandort = p.minStockByLocation;
+    if (jeStandort === undefined || jeStandort === null)
+        return;
+    if (typeof jeStandort !== 'object' || Array.isArray(jeStandort))
+        throw (0, endpunkte_js_1.anfragefehler)(name, 'minStockByLocation muss ein Objekt { standort: Tausendstel } sein');
+    for (const [standort, w] of Object.entries(jeStandort))
+        ganz(name, `minStockByLocation.${standort}`, w, { leerbar: true });
+}
+const artikelAus = (name, daten) => (0, lesen_js_1.artikel)({ name, pfad: 'article' }, (0, lesen_js_1.objekt)(daten)?.article);
+/**
+ * Legt einen Artikel an. Mit `ean` ein Fremdartikel mit diesem Code (gueltige
+ * Pruefziffer, frei im Konto), sonst vergibt der Server den naechsten eigenen
+ * Code. Antwort: der Artikel wie `getArticle`.
+ */
+async function createArticle(transport, request) {
+    const name = 'createArticle';
+    const p = anfrage(name, request);
+    schluessel(name, p, { pflicht: true });
+    artikelZahlen(name, p);
+    return artikelAus(name, await transport(name, p));
+}
+/** Aendert nur die genannten Felder eines Artikels (siehe [UpdateArticleRequest]). */
+async function updateArticle(transport, request) {
+    const name = 'updateArticle';
+    const p = anfrage(name, request);
+    schluessel(name, p, { pflicht: true });
+    (0, endpunkte_js_1.kennung)(name, 'articleId', p.articleId);
+    if (Object.keys(p).every((k) => k === 'idempotencyKey' || k === 'articleId')) {
+        throw (0, endpunkte_js_1.anfragefehler)(name, 'die Aenderung nennt kein Feld');
+    }
+    artikelZahlen(name, p);
+    return artikelAus(name, await transport(name, p));
+}
+/** Legt einen Artikel still (`active: false`); Code und eigene Kennungen werden frei. */
+async function deactivateArticle(transport, request) {
+    const name = 'deactivateArticle';
+    const p = anfrage(name, request);
+    schluessel(name, p, { pflicht: true });
+    (0, endpunkte_js_1.kennung)(name, 'articleId', p.articleId);
+    return artikelAus(name, await transport(name, p));
+}
+// ---- Buchen ------------------------------------------------------------------
+function eingangZahlen(name, p) {
+    positionen(name, p.items, { pflicht: true, menge: 'pflicht' }, (x, f) => {
+        for (const feld of ['totalCents', 'unitPriceMicros', 'landedCostCents'])
+            ganz(name, `${f}.${feld}`, x[feld]);
+    });
+    const nebenkosten = p.landedCosts;
+    if (nebenkosten === undefined)
+        return;
+    if (!Array.isArray(nebenkosten))
+        throw (0, endpunkte_js_1.anfragefehler)(name, 'landedCosts muss eine Liste sein');
+    nebenkosten.forEach((n, i) => {
+        if (n === null || typeof n !== 'object' || Array.isArray(n))
+            throw (0, endpunkte_js_1.anfragefehler)(name, `landedCosts[${i}] muss ein Objekt sein`);
+        ganz(name, `landedCosts[${i}].amountCents`, n.amountCents, { pflicht: true });
+    });
+}
+/**
+ * Bucht einen Wareneingang. Ohne `locationId` am Standard-Standort; die
+ * Antwort traegt keine Werte, auch mit dem Recht `costs` nicht. Fuer die
+ * Vorschau mit Werten: [previewGoodsReceipt].
+ */
+async function receiveGoods(transport, request) {
+    const name = 'receiveGoods';
+    const p = anfrage(name, request);
+    if (p.dryRun === true) {
+        throw (0, endpunkte_js_1.anfragefehler)(name, 'dryRun: true bucht nichts und liefert eine Vorschau statt eines Vorgangs; dafuer previewGoodsReceipt aufrufen');
+    }
+    schluessel(name, p, { pflicht: true });
+    eingangZahlen(name, p);
+    return (0, lesen_js_1.vorgang)(name, await transport(name, p));
+}
+/**
+ * Vorschau eines Wareneingangs (`receiveGoods` mit `dryRun: true`): prueft
+ * Positionen, Artikel, Preise und Nebenkosten und rechnet die Verteilung,
+ * schreibt aber nichts. Ein `idempotencyKey` ist freigestellt (`null` wie nicht
+ * angegeben, geht nicht hinaus) und wird nicht verbraucht; dieselbe Anfrage
+ * laesst sich danach mit ihm buchen. Werte
+ * (`baseCents` …) nur mit dem Recht `costs`. Den Standort prueft erst die Buchung.
+ */
+async function previewGoodsReceipt(transport, request) {
+    const name = 'receiveGoods';
+    const p = anfrage(name, request);
+    // null heisst hier „kein Schluessel“ und geht wie undefined nicht hinaus.
+    if (p.idempotencyKey === null)
+        delete p.idempotencyKey;
+    schluessel(name, p, { pflicht: false });
+    eingangZahlen(name, p);
+    // Ein Probelauf schreibt nichts: nach einem Zeitlimit bleibt er `rejected`,
+    // obwohl `receiveGoods` sonst Wirkung hat.
+    const daten = await transport(name, { ...p, dryRun: true }, undefined, undefined, { hasEffect: false });
+    return { preview: (0, lesen_js_1.liste)(name, daten, 'preview', lesen_js_1.vorschauZeile) };
+}
+const stueckPositionen = (name, p) => positionen(name, p.items, { pflicht: true, menge: 'pflicht' });
+/** Bucht Ware von einem Standort an einen anderen; ueberzieht nie (`exceeds_stock`). */
+async function transferStock(transport, request) {
+    const name = 'transferStock';
+    const p = anfrage(name, request);
+    schluessel(name, p, { pflicht: true });
+    (0, endpunkte_js_1.kennung)(name, 'fromLocationId', p.fromLocationId);
+    (0, endpunkte_js_1.kennung)(name, 'toLocationId', p.toLocationId);
+    stueckPositionen(name, p);
+    return (0, lesen_js_1.vorgang)(name, await transport(name, p));
+}
+/** Bucht einen Abgang (Bruch, Schwund, Diebstahl, Entnahme …); ueberzieht nie (`exceeds_stock`). */
+async function recordStockLoss(transport, request) {
+    const name = 'recordStockLoss';
+    const p = anfrage(name, request);
+    schluessel(name, p, { pflicht: true });
+    stueckPositionen(name, p);
+    return (0, lesen_js_1.vorgang)(name, await transport(name, p));
+}
+/** Bucht Ware zwischen `sellable` und `defective` um; ueberzieht nie (`exceeds_stock`). */
+async function changeStockCondition(transport, request) {
+    const name = 'changeStockCondition';
+    const p = anfrage(name, request);
+    schluessel(name, p, { pflicht: true });
+    stueckPositionen(name, p);
+    return (0, lesen_js_1.vorgang)(name, await transport(name, p));
+}
+/** Nimmt einen ganzen Vorgang (`operationId`) mit einer Gegenbuchung zurueck. */
+async function reverseStockMovement(transport, request) {
+    const name = 'reverseStockMovement';
+    const p = anfrage(name, request);
+    schluessel(name, p, { pflicht: true });
+    (0, endpunkte_js_1.kennung)(name, 'operationId', p.operationId);
+    return (0, lesen_js_1.vorgang)(name, await transport(name, p));
+}
+// ---- Reservierung ---------------------------------------------------------------
+const reservierungAus = (name, daten) => (0, lesen_js_1.reservierung)({ name, pfad: 'reservation' }, (0, lesen_js_1.objekt)(daten)?.reservation);
+/**
+ * Reserviert Ware (Checkout im Shop): ganz oder gar nicht, gemessen am
+ * verfuegbaren Bestand (`onHand − reserved`). Fehlt etwas, entsteht nichts:
+ * `insufficient_available`, die fehlenden Positionen in [inventoryShortfalls].
+ * Eingeloest wird ueber eine Rechnung (`issueInvoice` mit `items[].reservationId`),
+ * sonst laeuft die Reservierung ab und gibt die Ware wieder frei.
+ */
+async function createReservation(transport, request) {
+    const name = 'createReservation';
+    const p = anfrage(name, request);
+    schluessel(name, p, { pflicht: true });
+    positionen(name, p.items, { pflicht: true, menge: 'pflicht' });
+    minuten(name, p.expiresInMinutes, { pflicht: false });
+    return reservierungAus(name, await transport(name, p));
+}
+/** Verlaengert eine aktive Reservierung: neuer Ablauf = jetzt + `expiresInMinutes`. */
+async function extendReservation(transport, request) {
+    const name = 'extendReservation';
+    const p = anfrage(name, request);
+    schluessel(name, p, { pflicht: true });
+    (0, endpunkte_js_1.kennung)(name, 'reservationId', p.reservationId);
+    minuten(name, p.expiresInMinutes, { pflicht: true });
+    return reservierungAus(name, await transport(name, p));
+}
+/**
+ * Gibt reservierte Ware frei: ohne `items` alles, sonst je Position (ohne
+ * `quantity` der ganze offene Rest). Die Antwort traegt den Stand danach;
+ * `released` wird der Status erst, wenn nichts mehr offen ist.
+ */
+async function releaseReservation(transport, request) {
+    const name = 'releaseReservation';
+    const p = anfrage(name, request);
+    schluessel(name, p, { pflicht: true });
+    (0, endpunkte_js_1.kennung)(name, 'reservationId', p.reservationId);
+    if (Array.isArray(p.items) && p.items.length === 0) {
+        throw (0, endpunkte_js_1.anfragefehler)(name, 'items ist leer; um alles freizugeben, items ganz weglassen');
+    }
+    positionen(name, p.items, { pflicht: false, menge: 'frei' });
+    return reservierungAus(name, await transport(name, p));
+}
+/** Eine Reservierung mit ihrem aktuellen Stand. */
+async function getReservation(transport, reservationId) {
+    const name = 'getReservation';
+    return reservierungAus(name, await transport(name, { reservationId: (0, endpunkte_js_1.kennung)(name, 'reservationId', reservationId) }));
+}
+/** Reservierungen, neueste zuerst; Filter `status` und/oder `reference`. */
+async function listReservations(transport, query) {
+    const name = 'listReservations';
+    const daten = await transport(name, (0, endpunkte_js_1.abfrage)(name, query));
+    return { reservations: (0, lesen_js_1.liste)(name, daten, 'reservations', lesen_js_1.reservierung), nextCursor: (0, lesen_js_1.naechsterCursor)(name, daten) };
+}
+/** Alle Reservierungen der Abfrage, Seite fuer Seite ueber `nextCursor`. */
+function iterateReservations(transport, query) {
+    const { cursor, ...rest } = query ?? {};
+    return (0, endpunkte_js_1.seitenweise)('listReservations', cursor, async (c) => {
+        const s = await listReservations(transport, { ...rest, cursor: c });
+        return { eintraege: s.reservations, nextCursor: s.nextCursor };
+    });
+}