@kreiseck/kasseneck-api 1.7.0 → 1.8.0

package/dist/esm/inventory/inventur.js

@@ -0,0 +1,226 @@
+/**
+ * Inventur der Lager-API (Lager-Kern Stufe 3): anlegen, zaehlen, Zaehlungen
+ * stornieren, pruefen, nachzaehlen, abschliessen, abbrechen, Inventurprotokoll
+ * holen; dazu die Listen der Inventuren, Positionen und Zaehlungen.
+ *
+ * Ablauf: `createStocktake` → `recordStocktakeCount` (beliebig oft, auch von
+ * mehreren Geraeten; je Position addiert) → `reviewStocktake` (erst jetzt Soll
+ * und Differenz) → bei Bedarf `recountStocktake` und erneut `reviewStocktake`
+ * → `closeStocktake` → `getStocktakePdf`. Pruefen und Abschliessen rechnet der
+ * Server im Hintergrund: die Antwort traegt den Zwischenstand
+ * (`review.complete: false` bzw. `status: 'closing'`), `getStocktake` den
+ * Fortgang.
+ *
+ * **Blind:** vor `review` traegt keine Antwort ein Soll; `blind: false` zeigt
+ * beim Zaehlen nur den heutigen Buchbestand (`bookStockNow`), nie das Soll
+ * zur Referenzzeit.
+ *
+ * Rechte wie in Stufe 5b: Lesen mit jedem Schluessel, alles Schreibende (auch
+ * Zaehlen) mit dem Konto-Schalter „Lager-API schreiben“ (Test-Schluessel
+ * immer), sonst `inventory_api_not_enabled`; Werte und das Protokoll mit
+ * Werten nur mit `lagerApi.kosten`.
+ *
+ * **Vor dem Senden geprueft wird nur, was ohne Netz sicher falsch ist:**
+ * `idempotencyKey` (Pflicht bei jedem Schreiben, 1–120 Zeichen), fehlende
+ * Kennungen (`stocktakeId`, `articleId`, `countId`, `locationId`), `scope`
+ * kein Objekt, eine Menge, die keine Ganzzahl ist (Tausendstel), ein leerer
+ * Grund, `items` beim Nachzaehlen leer oder ohne `articleId`,
+ * `serialNumbers` keine Liste, `uncountedAsZero` kein Wahrheitswert. Alles
+ * Fachliche (Umfang, Stichtag, Seriennummern, Zustand) prueft der Server.
+ *
+ * **Wiederholen** wie bei jedem Schreiben: nach `outcome: 'unknown'` denselben
+ * Aufruf mit **demselben** `idempotencyKey`. Eine Zaehlung wirkt dann genau
+ * einmal (das Zaehldokument ist selbst der Nachweis); ein neuer Schluessel
+ * zaehlte die Ware ein zweites Mal.
+ */
+import { abfrage, anfragefehler, kennung, seitenweise } from './endpunkte.js';
+import { antwortfehler, inventur, inventurPosition, inventurWarnungen, inventurZaehlung, liste, naechsterCursor, objekt, protokollLink, zaehlungMitPosition, } from './lesen.js';
+import { anfrage, ganz, schluessel } from './schreiben.js';
+const istObjekt = (w) => w !== null && typeof w === 'object' && !Array.isArray(w);
+const kopfAus = (name, daten) => inventur({ name, pfad: 'stocktake' }, objekt(daten)?.stocktake);
+/** Ein Grund (Storno, Nachzaehlen, Abbruch): nicht leer. Die Laenge prueft der Server. */
+function grund(name, w) {
+    if (typeof w !== 'string' || w.trim() === '')
+        throw anfragefehler(name, 'reason fehlt (Grund mit 1 bis 500 Zeichen)');
+}
+/** Schreibende Anfrage mit `stocktakeId`: Schluessel und Kennung geprueft, flach wie gesendet. */
+function schreibend(name, request) {
+    const p = anfrage(name, request);
+    schluessel(name, p, { pflicht: true });
+    kennung(name, 'stocktakeId', p.stocktakeId);
+    return p;
+}
+/** Eine Liste unter einer Inventur: `stocktakeId` Pflicht, sonst wie jede Abfrage. */
+function abfrageMitInventur(name, query) {
+    if (!istObjekt(query))
+        throw anfragefehler(name, 'Abfrage mit stocktakeId erwartet');
+    const p = abfrage(name, query);
+    kennung(name, 'stocktakeId', p.stocktakeId);
+    return p;
+}
+// ---- Anlegen und Lesen -------------------------------------------------------------
+/**
+ * Legt eine Inventur an. Je Standort hoechstens eine offene
+ * (`stocktake_location_busy`, `data.stocktakeId` nennt sie); Umfang `groups`
+ * bzw. `articles` nur mit bestandsgefuehrten Artikeln (`article_not_tracked`).
+ * Jede Inventur beginnt in `counting`.
+ */
+export async function createStocktake(transport, request) {
+    const name = 'createStocktake';
+    const p = anfrage(name, request);
+    schluessel(name, p, { pflicht: true });
+    kennung(name, 'locationId', p.locationId);
+    if (!istObjekt(p.scope))
+        throw anfragefehler(name, 'scope fehlt oder ist kein Objekt { type, groupIds?, articleIds? }');
+    return kopfAus(name, await transport(name, p));
+}
+/**
+ * Inventuren des Kontos. Ohne `updatedSince` zuletzt geaenderte zuerst; mit
+ * `updatedSince` aufsteigend nach `updatedAt` und inklusive (Abgleich: das
+ * groesste gesehene `updatedAt` als naechstes `updatedSince`). Filter
+ * `status` und `locationId`.
+ */
+export async function listStocktakes(transport, query) {
+    const name = 'listStocktakes';
+    const daten = await transport(name, abfrage(name, query));
+    return { stocktakes: liste(name, daten, 'stocktakes', inventur), nextCursor: naechsterCursor(name, daten) };
+}
+/** Alle Inventuren der Abfrage, Seite fuer Seite, in der Reihenfolge von [listStocktakes]. */
+export function iterateStocktakes(transport, query) {
+    const { cursor, ...rest } = query ?? {};
+    return seitenweise('listStocktakes', cursor, async (c) => {
+        const s = await listStocktakes(transport, { ...rest, cursor: c });
+        return { eintraege: s.stocktakes, nextCursor: s.nextCursor };
+    });
+}
+/** Eine Inventur samt `progress.counted` (gezaehlte Positionen). */
+export async function getStocktake(transport, stocktakeId) {
+    const name = 'getStocktake';
+    return kopfAus(name, await transport(name, { stocktakeId: kennung(name, 'stocktakeId', stocktakeId) }));
+}
+/** Positionen einer Inventur nach Kennung; `openOnly` = ungezaehlt bzw. in `review` zum Nachzaehlen offen. */
+export async function listStocktakeItems(transport, query) {
+    const name = 'listStocktakeItems';
+    const daten = await transport(name, abfrageMitInventur(name, query));
+    return { items: liste(name, daten, 'items', inventurPosition), nextCursor: naechsterCursor(name, daten) };
+}
+export function iterateStocktakeItems(transport, query) {
+    const { cursor, ...rest } = query;
+    return seitenweise('listStocktakeItems', cursor, async (c) => {
+        const s = await listStocktakeItems(transport, { ...rest, cursor: c });
+        return { eintraege: s.items, nextCursor: s.nextCursor };
+    });
+}
+/** Zaehlungen einer Inventur, neueste zuerst, auch stornierte; mit `articleId` nur die des Artikels. */
+export async function listStocktakeCounts(transport, query) {
+    const name = 'listStocktakeCounts';
+    const daten = await transport(name, abfrageMitInventur(name, query));
+    return { counts: liste(name, daten, 'counts', inventurZaehlung), nextCursor: naechsterCursor(name, daten) };
+}
+export function iterateStocktakeCounts(transport, query) {
+    const { cursor, ...rest } = query;
+    return seitenweise('listStocktakeCounts', cursor, async (c) => {
+        const s = await listStocktakeCounts(transport, { ...rest, cursor: c });
+        return { eintraege: s.counts, nextCursor: s.nextCursor };
+    });
+}
+// ---- Zaehlen und Stornieren ------------------------------------------------------
+/** Pruefung einer Zaehlung vor dem Senden, geteilt mit dem Kassenweg. Paketintern. */
+export function zaehlungPruefen(name, p) {
+    kennung(name, 'articleId', p.articleId);
+    ganz(name, 'quantity', p.quantity, { pflicht: true });
+    if (p.serialNumbers !== undefined && p.serialNumbers !== null && !Array.isArray(p.serialNumbers)) {
+        throw anfragefehler(name, 'serialNumbers muss eine Liste sein');
+    }
+}
+/** Pruefung eines Stornos vor dem Senden, geteilt mit dem Kassenweg. Paketintern. */
+export function stornoPruefen(name, p) {
+    kennung(name, 'countId', p.countId);
+    grund(name, p.reason);
+}
+/**
+ * Eine Zaehlung. Antwort: die Zaehlung und ihre Position danach (Summe der
+ * Runde in `item.quantity`). Gezaehlt wird in `counting`, in `review` nur an
+ * Positionen, die zum Nachzaehlen frei sind (sonst `stocktake_not_open`).
+ */
+export async function recordStocktakeCount(transport, request) {
+    const name = 'recordStocktakeCount';
+    const p = schreibend(name, request);
+    zaehlungPruefen(name, p);
+    return zaehlungMitPosition(name, await transport(name, p));
+}
+/** Storniert eine Zaehlung mit Grund; die Position wird aus den uebrigen Zaehlungen neu summiert. */
+export async function voidStocktakeCount(transport, request) {
+    const name = 'voidStocktakeCount';
+    const p = schreibend(name, request);
+    stornoPruefen(name, p);
+    return zaehlungMitPosition(name, await transport(name, p));
+}
+// ---- Pruefen bis Abbruch ------------------------------------------------------------
+/**
+ * Pruefen: `counting` → `review`, in `review` neu rechnen (nach dem
+ * Nachzaehlen). Die Antwort kommt sofort mit `review.complete: false`; Soll
+ * und Differenz stehen an den Positionen, sobald `complete` `true` ist.
+ */
+export async function reviewStocktake(transport, request) {
+    const name = 'reviewStocktake';
+    return kopfAus(name, await transport(name, schreibend(name, request)));
+}
+/** Nachzaehlen: je genannter Position eine neue Runde; danach zaehlen und erneut [reviewStocktake]. */
+export async function recountStocktake(transport, request) {
+    const name = 'recountStocktake';
+    const p = schreibend(name, request);
+    if (!Array.isArray(p.items) || p.items.length === 0)
+        throw anfragefehler(name, 'items fehlt oder ist leer');
+    p.items.forEach((x, i) => {
+        if (!istObjekt(x))
+            throw anfragefehler(name, `items[${i}] muss ein Objekt sein`);
+        kennung(name, `items[${i}].articleId`, x.articleId);
+    });
+    grund(name, p.reason);
+    return kopfAus(name, await transport(name, p));
+}
+/**
+ * Abschliessen (nur aus `review`, sonst `stocktake_not_in_review`; offene
+ * Nachzaehlungen ergeben `stocktake_recount_open`). Der Server bucht in
+ * Teilen weiter; die Antwort traegt meist `status: 'closing'`. Ein erneuter
+ * Aufruf waehrend `closing` stoesst den Abschluss wieder an.
+ */
+export async function closeStocktake(transport, request) {
+    const name = 'closeStocktake';
+    const p = schreibend(name, request);
+    if (p.uncountedAsZero !== undefined && typeof p.uncountedAsZero !== 'boolean') {
+        throw anfragefehler(name, 'uncountedAsZero muss true oder false sein');
+    }
+    const daten = await transport(name, p);
+    return { stocktake: kopfAus(name, daten), warnings: inventurWarnungen({ name, pfad: 'warnings' }, objekt(daten)?.warnings) };
+}
+/** Abbrechen mit Grund (aus `counting` oder `review`); der Standort ist danach frei. */
+export async function cancelStocktake(transport, request) {
+    const name = 'cancelStocktake';
+    const p = schreibend(name, request);
+    grund(name, p.reason);
+    return kopfAus(name, await transport(name, p));
+}
+// ---- Protokoll ------------------------------------------------------------------
+/**
+ * Das Inventurprotokoll (PDF), erst nach dem Abschluss (`stocktake_not_closed`,
+ * auch fuer eine abgebrochene Inventur). Mit `lagerApi.kosten` die Fassung mit
+ * Werten, sonst die nur mit Mengen. Bis 9 MiB kommt die Datei selbst
+ * (`kind: 'pdf'`), darueber ein signierter Lese-Link fuer 15 Minuten
+ * (`kind: 'download'`); die geladene Datei an `download.sha256` pruefen.
+ *
+ * Als freie Funktion braucht sie den Transport aus `createPdfOrDataTransport`
+ * (Paketwurzel): ein JSON-Transport laese die Datei als Text, ein reiner
+ * Binaer-Transport kennt den Link nicht. [createInventoryClient] bindet ihn selbst.
+ */
+export async function getStocktakePdf(transport, stocktakeId) {
+    const name = 'getStocktakePdf';
+    const ergebnis = await transport(name, { stocktakeId: kennung(name, 'stocktakeId', stocktakeId) });
+    if ('pdf' in ergebnis)
+        return { kind: 'pdf', pdf: ergebnis.pdf };
+    const link = objekt(ergebnis.data)?.download;
+    if (link === undefined || link === null)
+        throw antwortfehler(name, 'Antwort ist weder ein PDF noch ein Lese-Link (data.download fehlt)');
+    return { kind: 'download', download: protokollLink(name, link) };
+}

package/dist/esm/inventory/lesen.d.ts

@@ -12,7 +12,7 @@
  * wenn der Server sie sendet: „fehlt“ heisst dort „kein Recht“, nicht „leer“.
  */
 import { KasseneckValidationError } from '../client/errors.js';
-import type { Article, GoodsReceiptPreviewLine, InventoryShortfall, InventoryWebhook, InventoryWebhookDelivery, InventoryWebhookTestDelivery, Location, Reservation, StockBelowMinimumEventData, StockChangedEventData, StockLevel, StockMovement, StockOperation, StockValue, VariantGroup } from './typen.js';
+import type { Article, GoodsReceiptPreviewLine, InventoryShortfall, InventoryWebhook, InventoryWebhookDelivery, InventoryWebhookTestDelivery, Location, Reservation, StockBelowMinimumEventData, StockChangedEventData, StockLevel, StockMovement, StockOperation, StockValue, Stocktake, StocktakeCount, StocktakeCountResult, StocktakeItem, StocktakePdfDownload, StocktakeWarning, VariantGroup } from './typen.js';
 type Roh = Record<string, unknown>;
 /** Ein Leser bekommt den Vorgang (fuer die Meldung) und den Pfad im Rumpf. */
 export interface Ort {
@@ -44,6 +44,25 @@ export declare function fehlmengen(roh: unknown): InventoryShortfall[];
  * bzw. „keine Varianten“).
  */
 export declare function variantengruppe(ort: Ort, w: unknown): VariantGroup;
+/** Hinweise einer Inventur; fehlt die Liste, gibt es keine. */
+export declare function inventurWarnungen(ort: Ort, w: unknown): StocktakeWarning[];
+/**
+ * Kopf einer Inventur. Was erst nach dem Abschluss kommt (Summen, Hinweise,
+ * Siegel, Pruefsumme, Protokoll), steht im Modell nur, wenn der Server es
+ * sendet; Werte nur mit dem Kosten-Recht.
+ */
+export declare function inventur(ort: Ort, w: unknown): Stocktake;
+/**
+ * Eine Position. Soll, Differenz und alles aus Pruefung und Abschluss stehen
+ * im Modell nur, wenn der Server sie sendet (blind: vor `review` nie).
+ */
+export declare function inventurPosition(ort: Ort, w: unknown): StocktakeItem;
+/** Eine Zaehlung: Menge, Runde und Kennungen muessen da sein. */
+export declare function inventurZaehlung(ort: Ort, w: unknown): StocktakeCount;
+/** Antwort von Zaehlen und Stornieren: beide Teile sind zugesagt. */
+export declare function zaehlungMitPosition(name: string, daten: unknown): StocktakeCountResult;
+/** Lese-Link auf ein grosses Inventurprotokoll; ohne Adresse, Ablauf, Groesse oder Pruefsumme ist er unbrauchbar. */
+export declare function protokollLink(name: string, w: unknown): StocktakePdfDownload;
 /** Eine zugesagte Liste `data.<feld>`, Eintrag fuer Eintrag gelesen. */
 export declare function liste<T>(name: string, daten: unknown, feld: string, lesen: (ort: Ort, e: unknown) => T): T[];
 /** Der Cursor der naechsten Seite; `null` am Ende. Etwas anderes als Text oder `null` ist kaputt. */

package/dist/esm/inventory/lesen.js

@@ -455,6 +455,307 @@ export function variantengruppe(ort, w) {
         updatedAt: text(g.updatedAt),
     };
 }
+// ---- Inventur (Lager-Kern Stufe 3) ---------------------------------------------------
+const unter = (ort, feld) => ({ name: ort.name, pfad: ort.pfad ? `${ort.pfad}.${feld}` : feld });
+/** Ein Unterobjekt, das `null` sein darf (`review`, `closing` …); etwas anderes als Objekt oder `null` ist kaputt. */
+function objektOderNull(ort, feld, w) {
+    if (w === undefined || w === null)
+        return null;
+    const o = objekt(w);
+    if (!o)
+        throw antwortfehler(ort.name, `Antwort ist unbrauchbar (data.${ort.pfad}.${feld} ist kein Objekt)`);
+    return o;
+}
+/** Ein Wahrheitswert, der da sein muss: ein fehlendes „gezaehlt“ ist nicht „ungezaehlt“. */
+function wahrheitswert(ort, feld, w) {
+    if (typeof w !== 'boolean')
+        throw antwortfehler(ort.name, `Antwort enthaelt keinen Wahrheitswert (data.${ort.pfad}.${feld})`);
+    return w;
+}
+/** Eine Liste von Texten, die fehlen darf (dann leer); etwas anderes ist kaputt. */
+function textlisteOderLeer(ort, feld, w) {
+    if (w === undefined || w === null)
+        return [];
+    return textliste(ort, feld, w);
+}
+/** Wer etwas tat; fehlt die Angabe, `null`. Etwas anderes als ein Objekt ist kaputt, nie still „niemand“. */
+function akteur(ort, feld, w) {
+    if (w === undefined || w === null)
+        return null;
+    const a = objekt(w);
+    if (!a)
+        throw antwortfehler(ort.name, `Antwort ist unbrauchbar (data.${ort.pfad}.${feld} ist kein Objekt)`);
+    return { type: textOderNull(a.type), id: textOderNull(a.id), name: textOderNull(a.name) };
+}
+function inventurWarnung(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, items: ganzzahl(ort, 'items', h.items), message: typeof h.message === 'string' ? h.message : null };
+}
+/** Hinweise einer Inventur; fehlt die Liste, gibt es keine. */
+export function inventurWarnungen(ort, w) {
+    if (w === undefined || w === null)
+        return [];
+    if (!Array.isArray(w))
+        throw antwortfehler(ort.name, `Antwort ist unbrauchbar (data.${ort.pfad} ist keine Liste)`);
+    return w.map((h, i) => inventurWarnung({ name: ort.name, pfad: `${ort.pfad}[${i}]` }, h));
+}
+function siegel(ort, w) {
+    const s = eintrag(ort, w);
+    const raus = {
+        fromDay: textOderNull(s.fromDay),
+        toDay: textOderNull(s.toDay),
+        daysChecked: ganzzahlOderNull(ort, 'daysChecked', s.daysChecked),
+        verified: typeof s.verified === 'boolean' ? s.verified : null,
+        firstBreak: textOderNull(s.firstBreak),
+        gaps: textlisteOderLeer(ort, 'gaps', s.gaps),
+        gapCount: ganzzahlOderNull(ort, 'gapCount', s.gapCount),
+    };
+    if (typeof s.notChecked === 'string')
+        raus.notChecked = s.notChecked;
+    if (hat(s, 'checkedUntil'))
+        raus.checkedUntil = textOderNull(s.checkedUntil);
+    return raus;
+}
+/**
+ * Kopf einer Inventur. Was erst nach dem Abschluss kommt (Summen, Hinweise,
+ * Siegel, Pruefsumme, Protokoll), steht im Modell nur, wenn der Server es
+ * sendet; Werte nur mit dem Kosten-Recht.
+ */
+export function inventur(ort, w) {
+    const k = eintrag(ort, w);
+    const umfang = objektOderNull(ort, 'scope', k.scope);
+    const umfangOrt = unter(ort, 'scope');
+    const fortschritt = objektOderNull(ort, 'progress', k.progress);
+    const fOrt = unter(ort, 'progress');
+    const pruefung = objektOderNull(ort, 'review', k.review);
+    const pOrt = unter(ort, 'review');
+    const abschluss = objektOderNull(ort, 'closing', k.closing);
+    const aOrt = unter(ort, 'closing');
+    const abbruch = objektOderNull(ort, 'cancellation', k.cancellation);
+    const raus = {
+        id: kennung(ort, 'id', k.id),
+        name: text(k.name),
+        locationId: textOderNull(k.locationId),
+        scope: umfang
+            ? {
+                type: textOderNull(umfang.type),
+                groupIds: textlisteOderLeer(umfangOrt, 'groupIds', umfang.groupIds),
+                articleIds: textlisteOderLeer(umfangOrt, 'articleIds', umfang.articleIds),
+            }
+            : null,
+        type: textOderNull(k.type),
+        keyDate: textOderNull(k.keyDate),
+        // Blind ist die sichere Vorgabe: nur ein ausdrueckliches false zeigt Bestand.
+        blind: k.blind !== false,
+        status: textOderNull(k.status),
+        progress: fortschritt
+            ? {
+                items: ganzzahl(fOrt, 'items', fortschritt.items),
+                counted: ganzzahlOderNull(fOrt, 'counted', fortschritt.counted),
+                recountOpen: fortschritt.recountOpen === true,
+            }
+            : null,
+        createdAt: text(k.createdAt),
+        createdBy: akteur(ort, 'createdBy', k.createdBy),
+        source: textOderNull(k.source),
+        updatedAt: text(k.updatedAt),
+        review: pruefung
+            ? {
+                startedAt: text(pruefung.startedAt),
+                startedBy: akteur(pOrt, 'startedBy', pruefung.startedBy),
+                complete: pruefung.complete === true,
+                expectedAsOf: text(pruefung.expectedAsOf),
+                recountUncounted: ganzzahlOderNull(pOrt, 'recountUncounted', pruefung.recountUncounted),
+            }
+            : null,
+        closing: abschluss
+            ? {
+                startedAt: text(abschluss.startedAt),
+                startedBy: akteur(aOrt, 'startedBy', abschluss.startedBy),
+                uncountedAsZero: abschluss.uncountedAsZero === true,
+                parts: ganzzahlOderNull(aOrt, 'parts', abschluss.parts),
+                bookedParts: ganzzahlOderNull(aOrt, 'bookedParts', abschluss.bookedParts),
+                completedAt: text(abschluss.completedAt),
+            }
+            : null,
+        cancellation: abbruch
+            ? { reason: text(abbruch.reason), cancelledAt: text(abbruch.cancelledAt), cancelledBy: akteur(unter(ort, 'cancellation'), 'cancelledBy', abbruch.cancelledBy) }
+            : null,
+    };
+    const summen = objektOderNull(ort, 'totals', k.totals);
+    if (summen) {
+        const sOrt = unter(ort, 'totals');
+        raus.totals = {
+            items: ganzzahl(sOrt, 'items', summen.items),
+            counted: ganzzahl(sOrt, 'counted', summen.counted),
+            uncounted: ganzzahl(sOrt, 'uncounted', summen.uncounted),
+            recounted: ganzzahl(sOrt, 'recounted', summen.recounted),
+            withDifference: ganzzahl(sOrt, 'withDifference', summen.withDifference),
+            needsCheck: ganzzahl(sOrt, 'needsCheck', summen.needsCheck),
+            notBooked: ganzzahl(sOrt, 'notBooked', summen.notBooked),
+        };
+        for (const feld of ['differenceValueCents', 'inventoryValueCents']) {
+            if (hat(summen, feld))
+                raus.totals[feld] = ganzzahlOderNull(sOrt, feld, summen[feld]);
+        }
+    }
+    if (hat(k, 'warnings'))
+        raus.warnings = inventurWarnungen(unter(ort, 'warnings'), k.warnings);
+    if (hat(k, 'seal') && k.seal !== null)
+        raus.seal = siegel(unter(ort, 'seal'), k.seal);
+    if (hat(k, 'checksum'))
+        raus.checksum = textOderNull(k.checksum);
+    if (hat(k, 'inventoryAsOf'))
+        raus.inventoryAsOf = textOderNull(k.inventoryAsOf);
+    const pdf = objektOderNull(ort, 'pdf', k.pdf);
+    if (pdf) {
+        raus.pdf = { available: pdf.available === true };
+        if (typeof pdf.valuesSha256 === 'string')
+            raus.pdf.valuesSha256 = pdf.valuesSha256;
+        if (typeof pdf.quantitiesSha256 === 'string')
+            raus.pdf.quantitiesSha256 = pdf.quantitiesSha256;
+    }
+    return raus;
+}
+function nichtGebucht(ort, w) {
+    const n = eintrag(ort, w);
+    if (typeof n.code !== 'string' || n.code === '')
+        throw antwortfehler(ort.name, `Antwort enthaelt keinen Grund (data.${ort.pfad}.code)`);
+    const raus = { code: n.code, quantity: ganzzahlOderNull(ort, 'quantity', n.quantity) };
+    if (n.reasons !== undefined && n.reasons !== null) {
+        if (!Array.isArray(n.reasons))
+            throw antwortfehler(ort.name, `Antwort ist unbrauchbar (data.${ort.pfad}.reasons ist keine Liste)`);
+        raus.reasons = n.reasons.map((g, i) => {
+            const gOrt = { name: ort.name, pfad: `${ort.pfad}.reasons[${i}]` };
+            const r = eintrag(gOrt, g);
+            if (typeof r.code !== 'string' || r.code === '')
+                throw antwortfehler(ort.name, `Antwort enthaelt keinen Grund (data.${gOrt.pfad}.code)`);
+            return { code: r.code, quantity: ganzzahlOderNull(gOrt, 'quantity', r.quantity) };
+        });
+    }
+    return raus;
+}
+/**
+ * Eine Position. Soll, Differenz und alles aus Pruefung und Abschluss stehen
+ * im Modell nur, wenn der Server sie sendet (blind: vor `review` nie).
+ */
+export function inventurPosition(ort, w) {
+    const p = eintrag(ort, w);
+    // Wer gezaehlt hat, ist zugesagt: fehlt die Liste, ist die Antwort kaputt (nie „niemand“).
+    if (!Array.isArray(p.countedBy))
+        throw antwortfehler(ort.name, `Antwort ist unbrauchbar (data.${ort.pfad}.countedBy ist keine Liste)`);
+    const zaehler = p.countedBy;
+    const nachzaehlen = objektOderNull(ort, 'recount', p.recount);
+    const nOrt = unter(ort, 'recount');
+    const raus = {
+        articleId: kennung(ort, 'articleId', p.articleId),
+        condition: kennung(ort, 'condition', p.condition),
+        name: text(p.name),
+        number: text(p.number),
+        unit: text(p.unit),
+        round: ganzzahl(ort, 'round', p.round),
+        counted: wahrheitswert(ort, 'counted', p.counted),
+        quantity: ganzzahlOderNull(ort, 'quantity', p.quantity),
+        counts: ganzzahl(ort, 'counts', p.counts),
+        firstCountedAt: text(p.firstCountedAt),
+        referenceTime: text(p.referenceTime),
+        countedBy: zaehler.map((a, i) => {
+            const wer = akteur(ort, `countedBy[${i}]`, a);
+            if (!wer)
+                throw antwortfehler(ort.name, `Antwort ist unbrauchbar (data.${ort.pfad}.countedBy[${i}] ist kein Objekt)`);
+            return wer;
+        }),
+        recountRequested: p.recountRequested === true,
+        recount: nachzaehlen
+            ? {
+                reason: text(nachzaehlen.reason),
+                requestedAt: text(nachzaehlen.requestedAt),
+                requestedBy: akteur(nOrt, 'requestedBy', nachzaehlen.requestedBy),
+                round: ganzzahlOderNull(nOrt, 'round', nachzaehlen.round),
+            }
+            : null,
+        addedLater: p.addedLater === true,
+    };
+    // Die Zaehl- und Storno-Antwort sendet die Position ohne Seriennummern: dann fehlt das Feld, nie [].
+    if (hat(p, 'serialNumbers'))
+        raus.serialNumbers = textlisteOderLeer(ort, 'serialNumbers', p.serialNumbers);
+    // Gezaehlt heisst: es gibt eine Menge. Beides zusammen kaputt waere „0“ oder „nichts“ geraten.
+    if (raus.counted && raus.quantity === null)
+        throw antwortfehler(ort.name, `Antwort ist unbrauchbar (data.${ort.pfad}.quantity fehlt bei counted: true)`);
+    for (const feld of ['bookStockNow', 'expectedQuantity', 'differenceQuantity', 'differenceValueCents', 'bookedQuantity']) {
+        if (hat(p, feld))
+            raus[feld] = ganzzahlOderNull(ort, feld, p[feld]);
+    }
+    if (hat(p, 'needsCheck'))
+        raus.needsCheck = p.needsCheck === true;
+    if (hat(p, 'checkReasons'))
+        raus.checkReasons = textlisteOderLeer(ort, 'checkReasons', p.checkReasons);
+    if (hat(p, 'expectedAsOf'))
+        raus.expectedAsOf = text(p.expectedAsOf);
+    if (hat(p, 'missingSerialNumbers'))
+        raus.missingSerialNumbers = textlisteOderLeer(ort, 'missingSerialNumbers', p.missingSerialNumbers);
+    if (hat(p, 'extraSerialNumbers'))
+        raus.extraSerialNumbers = textlisteOderLeer(ort, 'extraSerialNumbers', p.extraSerialNumbers);
+    if (hat(p, 'notBooked'))
+        raus.notBooked = p.notBooked === null ? null : nichtGebucht(unter(ort, 'notBooked'), p.notBooked);
+    if (hat(p, 'inventory')) {
+        const inv = objektOderNull(ort, 'inventory', p.inventory);
+        if (!inv) {
+            raus.inventory = null;
+        }
+        else {
+            const iOrt = unter(ort, 'inventory');
+            raus.inventory = { quantity: ganzzahl(iOrt, 'quantity', inv.quantity), countedOn: textOderNull(inv.countedOn) };
+            for (const feld of ['unitValueMicros', 'valueCents']) {
+                if (hat(inv, feld))
+                    raus.inventory[feld] = ganzzahlOderNull(iOrt, feld, inv[feld]);
+            }
+        }
+    }
+    return raus;
+}
+/** Eine Zaehlung: Menge, Runde und Kennungen muessen da sein. */
+export function inventurZaehlung(ort, w) {
+    const z = eintrag(ort, w);
+    const storno = objektOderNull(ort, 'voided', z.voided);
+    return {
+        id: kennung(ort, 'id', z.id),
+        articleId: kennung(ort, 'articleId', z.articleId),
+        condition: kennung(ort, 'condition', z.condition),
+        quantity: ganzzahl(ort, 'quantity', z.quantity),
+        // Die Zaehlung traegt ihre Seriennummern immer (leer bei Mengenartikeln); fehlt die Liste, ist sie kaputt.
+        serialNumbers: textliste(ort, 'serialNumbers', z.serialNumbers),
+        round: ganzzahl(ort, 'round', z.round),
+        countedBy: akteur(ort, 'countedBy', z.countedBy),
+        source: textOderNull(z.source),
+        cashregisterId: textOderNull(z.cashregisterId),
+        countedAt: text(z.countedAt),
+        note: text(z.note),
+        voided: storno
+            ? { reason: text(storno.reason), voidedAt: text(storno.voidedAt), voidedBy: akteur(unter(ort, 'voided'), 'voidedBy', storno.voidedBy) }
+            : null,
+    };
+}
+/** Antwort von Zaehlen und Stornieren: beide Teile sind zugesagt. */
+export function zaehlungMitPosition(name, daten) {
+    const d = objekt(daten);
+    return { count: inventurZaehlung({ name, pfad: 'count' }, d?.count), item: inventurPosition({ name, pfad: 'item' }, d?.item) };
+}
+/** Lese-Link auf ein grosses Inventurprotokoll; ohne Adresse, Ablauf, Groesse oder Pruefsumme ist er unbrauchbar. */
+export function protokollLink(name, w) {
+    const ort = { name, pfad: 'download' };
+    const d = eintrag(ort, w);
+    return {
+        url: kennung(ort, 'url', d.url),
+        expiresAt: kennung(ort, 'expiresAt', d.expiresAt),
+        sizeBytes: ganzzahl(ort, 'sizeBytes', d.sizeBytes),
+        sha256: kennung(ort, 'sha256', d.sha256),
+        fileName: textOderNull(d.fileName),
+        contentType: textOderNull(d.contentType),
+    };
+}
 // ---- Listen ------------------------------------------------------------------
 /** Eine zugesagte Liste `data.<feld>`, Eintrag fuer Eintrag gelesen. */
 export function liste(name, daten, feld, lesen) {