@kreiseck/kasseneck-api 1.7.1 → 1.10.0

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

@@ -0,0 +1,104 @@
+/**
+ * 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 type { ApiCall, InternerPdfOderDatenTransport, InternerTransport } from '../client/aufrufe.js';
+import type { CancelStocktakeRequest, CloseStocktakeRequest, CloseStocktakeResult, CreateStocktakeRequest, RecordStocktakeCountRequest, RecountStocktakeRequest, ReviewStocktakeRequest, Stocktake, StocktakeCount, StocktakeCountListQuery, StocktakeCountPage, StocktakeCountResult, StocktakeItem, StocktakeItemListQuery, StocktakeItemPage, StocktakeListQuery, StocktakePage, StocktakePdf, VoidStocktakeCountRequest } from './typen.js';
+type Params = Record<string, unknown>;
+/**
+ * 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 declare function createStocktake(transport: InternerTransport, request: CreateStocktakeRequest): Promise<Stocktake>;
+/**
+ * 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 declare function listStocktakes(transport: InternerTransport, query?: StocktakeListQuery): Promise<StocktakePage>;
+/** Alle Inventuren der Abfrage, Seite fuer Seite, in der Reihenfolge von [listStocktakes]. */
+export declare function iterateStocktakes(transport: InternerTransport, query?: StocktakeListQuery): AsyncGenerator<Stocktake, void, undefined>;
+/** Eine Inventur samt `progress.counted` (gezaehlte Positionen). */
+export declare function getStocktake(transport: InternerTransport, stocktakeId: string): Promise<Stocktake>;
+/** Positionen einer Inventur nach Kennung; `openOnly` = ungezaehlt bzw. in `review` zum Nachzaehlen offen. */
+export declare function listStocktakeItems(transport: InternerTransport, query: StocktakeItemListQuery): Promise<StocktakeItemPage>;
+export declare function iterateStocktakeItems(transport: InternerTransport, query: StocktakeItemListQuery): AsyncGenerator<StocktakeItem, void, undefined>;
+/** Zaehlungen einer Inventur, neueste zuerst, auch stornierte; mit `articleId` nur die des Artikels. */
+export declare function listStocktakeCounts(transport: InternerTransport, query: StocktakeCountListQuery): Promise<StocktakeCountPage>;
+export declare function iterateStocktakeCounts(transport: InternerTransport, query: StocktakeCountListQuery): AsyncGenerator<StocktakeCount, void, undefined>;
+/** Pruefung einer Zaehlung vor dem Senden, geteilt mit dem Kassenweg. Paketintern. */
+export declare function zaehlungPruefen(name: ApiCall, p: Params): void;
+/** Pruefung eines Stornos vor dem Senden, geteilt mit dem Kassenweg. Paketintern. */
+export declare function stornoPruefen(name: ApiCall, p: Params): void;
+/**
+ * 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 declare function recordStocktakeCount(transport: InternerTransport, request: RecordStocktakeCountRequest): Promise<StocktakeCountResult>;
+/** Storniert eine Zaehlung mit Grund; die Position wird aus den uebrigen Zaehlungen neu summiert. */
+export declare function voidStocktakeCount(transport: InternerTransport, request: VoidStocktakeCountRequest): Promise<StocktakeCountResult>;
+/**
+ * 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 declare function reviewStocktake(transport: InternerTransport, request: ReviewStocktakeRequest): Promise<Stocktake>;
+/** Nachzaehlen: je genannter Position eine neue Runde; danach zaehlen und erneut [reviewStocktake]. */
+export declare function recountStocktake(transport: InternerTransport, request: RecountStocktakeRequest): Promise<Stocktake>;
+/**
+ * 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 declare function closeStocktake(transport: InternerTransport, request: CloseStocktakeRequest): Promise<CloseStocktakeResult>;
+/** Abbrechen mit Grund (aus `counting` oder `review`); der Standort ist danach frei. */
+export declare function cancelStocktake(transport: InternerTransport, request: CancelStocktakeRequest): Promise<Stocktake>;
+/**
+ * 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 declare function getStocktakePdf(transport: InternerPdfOderDatenTransport, stocktakeId: string): Promise<StocktakePdf>;
+export {};

package/dist/cjs/inventory/inventur.js

@@ -0,0 +1,245 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStocktake = createStocktake;
+exports.listStocktakes = listStocktakes;
+exports.iterateStocktakes = iterateStocktakes;
+exports.getStocktake = getStocktake;
+exports.listStocktakeItems = listStocktakeItems;
+exports.iterateStocktakeItems = iterateStocktakeItems;
+exports.listStocktakeCounts = listStocktakeCounts;
+exports.iterateStocktakeCounts = iterateStocktakeCounts;
+exports.zaehlungPruefen = zaehlungPruefen;
+exports.stornoPruefen = stornoPruefen;
+exports.recordStocktakeCount = recordStocktakeCount;
+exports.voidStocktakeCount = voidStocktakeCount;
+exports.reviewStocktake = reviewStocktake;
+exports.recountStocktake = recountStocktake;
+exports.closeStocktake = closeStocktake;
+exports.cancelStocktake = cancelStocktake;
+exports.getStocktakePdf = getStocktakePdf;
+const endpunkte_js_1 = require("./endpunkte.js");
+const lesen_js_1 = require("./lesen.js");
+const schreiben_js_1 = require("./schreiben.js");
+const istObjekt = (w) => w !== null && typeof w === 'object' && !Array.isArray(w);
+const kopfAus = (name, daten) => (0, lesen_js_1.inventur)({ name, pfad: 'stocktake' }, (0, lesen_js_1.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 (0, endpunkte_js_1.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 = (0, schreiben_js_1.anfrage)(name, request);
+    (0, schreiben_js_1.schluessel)(name, p, { pflicht: true });
+    (0, endpunkte_js_1.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 (0, endpunkte_js_1.anfragefehler)(name, 'Abfrage mit stocktakeId erwartet');
+    const p = (0, endpunkte_js_1.abfrage)(name, query);
+    (0, endpunkte_js_1.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`.
+ */
+async function createStocktake(transport, request) {
+    const name = 'createStocktake';
+    const p = (0, schreiben_js_1.anfrage)(name, request);
+    (0, schreiben_js_1.schluessel)(name, p, { pflicht: true });
+    (0, endpunkte_js_1.kennung)(name, 'locationId', p.locationId);
+    if (!istObjekt(p.scope))
+        throw (0, endpunkte_js_1.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`.
+ */
+async function listStocktakes(transport, query) {
+    const name = 'listStocktakes';
+    const daten = await transport(name, (0, endpunkte_js_1.abfrage)(name, query));
+    return { stocktakes: (0, lesen_js_1.liste)(name, daten, 'stocktakes', lesen_js_1.inventur), nextCursor: (0, lesen_js_1.naechsterCursor)(name, daten) };
+}
+/** Alle Inventuren der Abfrage, Seite fuer Seite, in der Reihenfolge von [listStocktakes]. */
+function iterateStocktakes(transport, query) {
+    const { cursor, ...rest } = query ?? {};
+    return (0, endpunkte_js_1.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). */
+async function getStocktake(transport, stocktakeId) {
+    const name = 'getStocktake';
+    return kopfAus(name, await transport(name, { stocktakeId: (0, endpunkte_js_1.kennung)(name, 'stocktakeId', stocktakeId) }));
+}
+/** Positionen einer Inventur nach Kennung; `openOnly` = ungezaehlt bzw. in `review` zum Nachzaehlen offen. */
+async function listStocktakeItems(transport, query) {
+    const name = 'listStocktakeItems';
+    const daten = await transport(name, abfrageMitInventur(name, query));
+    return { items: (0, lesen_js_1.liste)(name, daten, 'items', lesen_js_1.inventurPosition), nextCursor: (0, lesen_js_1.naechsterCursor)(name, daten) };
+}
+function iterateStocktakeItems(transport, query) {
+    const { cursor, ...rest } = query;
+    return (0, endpunkte_js_1.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. */
+async function listStocktakeCounts(transport, query) {
+    const name = 'listStocktakeCounts';
+    const daten = await transport(name, abfrageMitInventur(name, query));
+    return { counts: (0, lesen_js_1.liste)(name, daten, 'counts', lesen_js_1.inventurZaehlung), nextCursor: (0, lesen_js_1.naechsterCursor)(name, daten) };
+}
+function iterateStocktakeCounts(transport, query) {
+    const { cursor, ...rest } = query;
+    return (0, endpunkte_js_1.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. */
+function zaehlungPruefen(name, p) {
+    (0, endpunkte_js_1.kennung)(name, 'articleId', p.articleId);
+    (0, schreiben_js_1.ganz)(name, 'quantity', p.quantity, { pflicht: true });
+    if (p.serialNumbers !== undefined && p.serialNumbers !== null && !Array.isArray(p.serialNumbers)) {
+        throw (0, endpunkte_js_1.anfragefehler)(name, 'serialNumbers muss eine Liste sein');
+    }
+}
+/** Pruefung eines Stornos vor dem Senden, geteilt mit dem Kassenweg. Paketintern. */
+function stornoPruefen(name, p) {
+    (0, endpunkte_js_1.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`).
+ */
+async function recordStocktakeCount(transport, request) {
+    const name = 'recordStocktakeCount';
+    const p = schreibend(name, request);
+    zaehlungPruefen(name, p);
+    return (0, lesen_js_1.zaehlungMitPosition)(name, await transport(name, p));
+}
+/** Storniert eine Zaehlung mit Grund; die Position wird aus den uebrigen Zaehlungen neu summiert. */
+async function voidStocktakeCount(transport, request) {
+    const name = 'voidStocktakeCount';
+    const p = schreibend(name, request);
+    stornoPruefen(name, p);
+    return (0, lesen_js_1.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.
+ */
+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]. */
+async function recountStocktake(transport, request) {
+    const name = 'recountStocktake';
+    const p = schreibend(name, request);
+    if (!Array.isArray(p.items) || p.items.length === 0)
+        throw (0, endpunkte_js_1.anfragefehler)(name, 'items fehlt oder ist leer');
+    p.items.forEach((x, i) => {
+        if (!istObjekt(x))
+            throw (0, endpunkte_js_1.anfragefehler)(name, `items[${i}] muss ein Objekt sein`);
+        (0, endpunkte_js_1.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.
+ */
+async function closeStocktake(transport, request) {
+    const name = 'closeStocktake';
+    const p = schreibend(name, request);
+    if (p.uncountedAsZero !== undefined && typeof p.uncountedAsZero !== 'boolean') {
+        throw (0, endpunkte_js_1.anfragefehler)(name, 'uncountedAsZero muss true oder false sein');
+    }
+    const daten = await transport(name, p);
+    return { stocktake: kopfAus(name, daten), warnings: (0, lesen_js_1.inventurWarnungen)({ name, pfad: 'warnings' }, (0, lesen_js_1.objekt)(daten)?.warnings) };
+}
+/** Abbrechen mit Grund (aus `counting` oder `review`); der Standort ist danach frei. */
+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.
+ */
+async function getStocktakePdf(transport, stocktakeId) {
+    const name = 'getStocktakePdf';
+    const ergebnis = await transport(name, { stocktakeId: (0, endpunkte_js_1.kennung)(name, 'stocktakeId', stocktakeId) });
+    if ('pdf' in ergebnis)
+        return { kind: 'pdf', pdf: ergebnis.pdf };
+    const link = (0, lesen_js_1.objekt)(ergebnis.data)?.download;
+    if (link === undefined || link === null)
+        throw (0, lesen_js_1.antwortfehler)(name, 'Antwort ist weder ein PDF noch ein Lese-Link (data.download fehlt)');
+    return { kind: 'download', download: (0, lesen_js_1.protokollLink)(name, link) };
+}

package/dist/cjs/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. */