@kreiseck/kasseneck-api 1.7.1 → 1.8.0

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

@@ -10,7 +10,7 @@
  * Zeitpunkte sind ISO 8601 in UTC (`2026-10-06T08:15:00.000Z`), Tage (Wiener
  * Tag) `YYYY-MM-DD`.
  */
-import type { InventoryWarningCode, InventoryWebhookEventType, LandedCostAllocation, LandedCostType, LocationType, ReservationStatus, StockChangeCause, StockCondition, StockKind, StockLossReason, StockMovementSource, StockMovementType, WebhookDeliveryStatus, WithdrawalType } from './vertrag.js';
+import type { InventoryWarningCode, InventoryWebhookEventType, LandedCostAllocation, LandedCostType, LocationType, ReservationStatus, StockChangeCause, StockCondition, StockKind, StockLossReason, StockMovementSource, StockMovementType, StocktakeActorType, StocktakeCheckReason, StocktakeInventoryAsOf, StocktakeNotBookedReason, StocktakeScopeType, StocktakeSource, StocktakeStatus, StocktakeType, WebhookDeliveryStatus, WithdrawalType } from './vertrag.js';
 /**
  * Ein Artikel, wie `getArticle`, `listArticles`, `lookupArticleByCode` und die
  * Ereignisse `article.*` ihn senden.
@@ -831,3 +831,412 @@ export interface VariantGroupPage {
     /** `null` = letzte Seite. */
     nextCursor: string | null;
 }
+/** Wer etwas tat: Inhaber, Kasseneck-Admin, Kassen-Benutzer oder ein API-Schluessel. */
+export interface StocktakeActor {
+    /** `null`: ein Wert, den diese Paketversion nicht kennt, steht als Text, sonst keiner. */
+    type: StocktakeActorType | (string & {}) | null;
+    id: string | null;
+    /** Anzeigename (Kassen-Benutzer); `null` beim Inhaber und bei der API. */
+    name: string | null;
+}
+/** Umfang einer Inventur, bei der Anlage eingefroren. */
+export interface StocktakeScope {
+    type: StocktakeScopeType | (string & {}) | null;
+    /** Nur bei `groups`, sonst leer. */
+    groupIds: string[];
+    /** Nur bei `articles`, sonst leer. */
+    articleIds: string[];
+}
+/** Fortschritt: Zahl der Positionen und ob Positionen zum Nachzaehlen offen sind. */
+export interface StocktakeProgress {
+    items: number;
+    /**
+     * Gezaehlte Positionen; nur `getStocktake` zaehlt sie (sonst `null`, nie 0:
+     * „unbekannt“ ist nicht „keine“).
+     */
+    counted: number | null;
+    recountOpen: boolean;
+}
+/** Die Pruefung: wann und von wem angestossen, ob Soll und Differenz schon gerechnet sind. */
+export interface StocktakeReview {
+    startedAt: string | null;
+    startedBy: StocktakeActor | null;
+    /** `false`: der Server rechnet noch; danach erneut `getStocktake`. */
+    complete: boolean;
+    /** Stand der Soll-Rechnung; `null`, solange sie nicht fertig ist. */
+    expectedAsOf: string | null;
+    /** Positionen, die zum Nachzaehlen offen und noch ungezaehlt sind; `null`, wenn der Server es nicht nennt. */
+    recountUncounted: number | null;
+}
+/** Der Abschluss: er bucht in Teilen, wiederaufnehmbar. */
+export interface StocktakeClosing {
+    startedAt: string | null;
+    startedBy: StocktakeActor | null;
+    /** Ungezaehlte Positionen als 0 gebucht (sonst nicht gebucht, im Protokoll „nicht gezaehlt“). */
+    uncountedAsZero: boolean;
+    /** Zahl der Teile; `null`, solange der Plan noch nicht steht. */
+    parts: number | null;
+    /** Gebuchte Teile; `null`, wenn der Server es nicht nennt. */
+    bookedParts: number | null;
+    completedAt: string | null;
+}
+export interface StocktakeCancellation {
+    reason: string | null;
+    cancelledAt: string | null;
+    cancelledBy: StocktakeActor | null;
+}
+/** Summen des Abschlusses (Anzahlen; Werte nur mit `lagerApi.kosten`). */
+export interface StocktakeTotals {
+    items: number;
+    counted: number;
+    uncounted: number;
+    recounted: number;
+    withDifference: number;
+    needsCheck: number;
+    notBooked: number;
+    /** Summe der gebuchten Differenzwerte in Cent; nur mit `lagerApi.kosten`. */
+    differenceValueCents?: number | null;
+    /** Inventarwert in Cent; nur mit `lagerApi.kosten`. */
+    inventoryValueCents?: number | null;
+}
+/** Ein Hinweis zur Inventur, mit der Zahl der betroffenen Positionen. */
+export interface StocktakeWarning {
+    code: InventoryWarningCode | (string & {});
+    items: number;
+    /** Menschentext (deutsch); `null` am Kopf, der nur Codes fuehrt. */
+    message: string | null;
+}
+/**
+ * Siegelstand des Lagerprotokolls beim Abschluss: Wiener Tage `YYYY-MM-DD`.
+ * `verified: null` heisst „nicht fertig geprueft“, nie Bruch.
+ */
+export interface StocktakeSeal {
+    fromDay: string | null;
+    toDay: string | null;
+    daysChecked: number | null;
+    verified: boolean | null;
+    /** Erster Tag mit gebrochenem Siegel; `null` = keiner. */
+    firstBreak: string | null;
+    /** Tage ohne Siegel. */
+    gaps: string[];
+    gapCount: number | null;
+    /** `time_limit` (Frist des Laufs) oder `unavailable`; fehlt, wenn ganz geprueft. */
+    notChecked?: string;
+    /** Bis wohin geprueft wurde, wenn die Pruefung nicht fertig wurde. */
+    checkedUntil?: string | null;
+}
+/** Das Inventurprotokoll: ob es da ist, und die Pruefsummen der Fassungen, die der Aufrufer sehen darf. */
+export interface StocktakePdfInfo {
+    available: boolean;
+    /** SHA-256 der Fassung mit Werten; nur mit `lagerApi.kosten`. */
+    valuesSha256?: string;
+    /** SHA-256 der Fassung nur mit Mengen. */
+    quantitiesSha256?: string;
+}
+/**
+ * Eine Inventur (Kopf), wie jeder Inventur-Aufruf ausser den Listen der
+ * Positionen und Zaehlungen sie sendet.
+ *
+ * Die Felder des Ergebnisses (`totals`, `warnings`, `seal`, `checksum`,
+ * `inventoryAsOf`, `pdf`) gibt es erst nach dem Abschluss; vorher fehlen sie.
+ */
+export interface Stocktake {
+    id: string;
+    /** 1–100 Zeichen, Vorgabe „Inventur <Standort> <Tag>“. */
+    name: string | null;
+    locationId: string | null;
+    scope: StocktakeScope | null;
+    type: StocktakeType | (string & {}) | null;
+    /** `YYYY-MM-DD` bei `key_date`, sonst `null`. */
+    keyDate: string | null;
+    /** Blind zaehlen (Vorgabe): niemand sieht vor der Pruefung ein Soll. */
+    blind: boolean;
+    status: StocktakeStatus | (string & {}) | null;
+    progress: StocktakeProgress | null;
+    createdAt: string | null;
+    createdBy: StocktakeActor | null;
+    source: StocktakeSource | (string & {}) | null;
+    /** Letzte Aenderung des Kopfs; Grundlage von `listStocktakes({ updatedSince })`. */
+    updatedAt: string | null;
+    review: StocktakeReview | null;
+    closing: StocktakeClosing | null;
+    cancellation: StocktakeCancellation | null;
+    totals?: StocktakeTotals;
+    /** Hinweise des Abschlusses (`uncounted_items`, `not_booked`, `defect_capped`). */
+    warnings?: StocktakeWarning[];
+    seal?: StocktakeSeal;
+    /** SHA-256 ueber Kopf, Positionen und Zaehlungen (kanonisches JSON), steht auch im Protokoll. */
+    checksum?: string | null;
+    inventoryAsOf?: StocktakeInventoryAsOf | (string & {}) | null;
+    pdf?: StocktakePdfInfo;
+}
+/** Ein Nachzaehlen-Auftrag an einer Position. */
+export interface StocktakeRecount {
+    reason: string | null;
+    requestedAt: string | null;
+    requestedBy: StocktakeActor | null;
+    /** Die Runde, die das Nachzaehlen begann. */
+    round: number | null;
+}
+/** Was von einer Position nicht gebucht wurde, und warum. */
+export interface StocktakeNotBooked {
+    code: StocktakeNotBookedReason | (string & {});
+    /** Nicht gebuchte Menge in Tausendstel; `null`, wenn der Server keine nennt. */
+    quantity: number | null;
+    /** Bei mehreren Gruenden je Grund ein Eintrag; fehlt sonst. */
+    reasons?: Array<{
+        code: StocktakeNotBookedReason | (string & {});
+        quantity: number | null;
+    }>;
+}
+/** Eine Zeile des Inventars (nach dem Abschluss). */
+export interface StocktakeInventoryLine {
+    quantity: number;
+    /** Aufnahmetag (Wiener Tag der Referenzzeit), `YYYY-MM-DD`. */
+    countedOn: string | null;
+    /** Einzelwert je Basiseinheit in Mikro-Euro; nur mit `lagerApi.kosten`. */
+    unitValueMicros?: number | null;
+    /** Gesamtwert in Cent; nur mit `lagerApi.kosten`. */
+    valueCents?: number | null;
+}
+/**
+ * Eine Position: ein Artikel in einem Zustand (`sellable` bzw. `defective`).
+ *
+ * Ab `review` (und nur dann) kommen Soll, Differenz und „pruefen“ dazu
+ * (`expectedQuantity` …), nach dem Abschluss die Buchung und das Inventar.
+ * Vorher fehlen diese Felder ganz.
+ */
+export interface StocktakeItem {
+    articleId: string;
+    condition: StockCondition | (string & {});
+    /** Name, Nummer und Einheit, wie sie bei der Anlage galten. */
+    name: string | null;
+    number: string | null;
+    unit: string | null;
+    /** Zaehlrunde ab 1; jedes Nachzaehlen beginnt eine neue. */
+    round: number;
+    /** Gezaehlt (auch „0 gezaehlt“); `false` heisst ungezaehlt, nicht leer. */
+    counted: boolean;
+    /** Summe der aktiven Zaehlungen der Runde in Tausendstel; `null` = nicht gezaehlt. */
+    quantity: number | null;
+    /** Zahl der aktiven Zaehlungen der Runde. */
+    counts: number;
+    firstCountedAt: string | null;
+    /** Referenzzeit: Serverzeit der letzten aktiven Zaehlung der Runde. */
+    referenceTime: string | null;
+    countedBy: StocktakeActor[];
+    /**
+     * Gezaehlte Seriennummern der Runde (Einzelstuecke). Nur in den Listen;
+     * die Antwort von Zaehlen und Stornieren sendet die Position ohne sie, dann
+     * fehlt das Feld (nicht „keine Seriennummern“).
+     */
+    serialNumbers?: string[];
+    recountRequested: boolean;
+    recount: StocktakeRecount | null;
+    /** Erst beim Zaehlen aufgenommen (Umfang `all`). */
+    addedLater: boolean;
+    /**
+     * Heutiger Buchbestand in Tausendstel, nur bei `blind: false` waehrend der
+     * Zaehlung. Nie das Soll zur Referenzzeit.
+     */
+    bookStockNow?: number | null;
+    expectedQuantity?: number | null;
+    /** `quantity − expectedQuantity`; `null`, wenn ungezaehlt. */
+    differenceQuantity?: number | null;
+    needsCheck?: boolean;
+    checkReasons?: Array<StocktakeCheckReason | (string & {})>;
+    expectedAsOf?: string | null;
+    /** Voraussichtlicher (in `review`) bzw. gebuchter Differenzwert in Cent; nur mit `lagerApi.kosten`. */
+    differenceValueCents?: number | null;
+    /** Einzelstueck: Soll-Nummern ohne Zaehlung. */
+    missingSerialNumbers?: string[];
+    /** Einzelstueck: gezaehlte Nummern, die nicht im Soll stehen. */
+    extraSerialNumbers?: string[];
+    /** Gebuchte Menge in Tausendstel (nach dem Abschluss). */
+    bookedQuantity?: number | null;
+    notBooked?: StocktakeNotBooked | null;
+    inventory?: StocktakeInventoryLine | null;
+}
+/** Eine Zaehlung. */
+export interface StocktakeCount {
+    id: string;
+    articleId: string;
+    condition: StockCondition | (string & {});
+    /** Tausendstel; `0` heisst „leer gezaehlt“. */
+    quantity: number;
+    serialNumbers: string[];
+    round: number;
+    countedBy: StocktakeActor | null;
+    source: StocktakeSource | (string & {}) | null;
+    /** Kasse, an der gezaehlt wurde; `null` im Panel und ueber die API. */
+    cashregisterId: string | null;
+    /** Serverzeit der Zaehlung (die Geraetezeit zaehlt nie). */
+    countedAt: string | null;
+    note: string | null;
+    /** `null` = aktiv. */
+    voided: {
+        reason: string | null;
+        voidedAt: string | null;
+        voidedBy: StocktakeActor | null;
+    } | null;
+}
+/** Antwort von Zaehlen und Stornieren: die Zaehlung und ihre Position danach. */
+export interface StocktakeCountResult {
+    count: StocktakeCount;
+    item: StocktakeItem;
+}
+export interface StocktakeScopeInput {
+    type: StocktakeScopeType;
+    /** Bei `groups`: 1–50 Gruppen. */
+    groupIds?: string[];
+    /** Bei `articles`: 1–5000 bestandsgefuehrte Artikel. */
+    articleIds?: string[];
+}
+/**
+ * Legt eine Inventur an. Je Standort hoechstens eine offene
+ * (`stocktake_location_busy` mit `data.stocktakeId`); hoechstens
+ * [STOCKTAKE_ITEMS_MAX] Positionen.
+ */
+export interface CreateStocktakeRequest {
+    idempotencyKey: string;
+    locationId: string;
+    scope: StocktakeScopeInput;
+    type: StocktakeType;
+    /** Pflicht bei `key_date` (`YYYY-MM-DD`), sonst weglassen oder `null`. */
+    keyDate?: string | null;
+    /** Vorgabe `true`. */
+    blind?: boolean;
+    /** 1–100 Zeichen; ohne Angabe „Inventur <Standort> <Tag>“. */
+    name?: string | null;
+}
+/**
+ * Inventuren des Kontos. Ohne `updatedSince` zuletzt geaenderte zuerst
+ * (`updatedAt` absteigend); offene stehen dabei nicht zwingend oben, dafuer
+ * gibt es den Filter `status`. Mit `updatedSince` aufsteigend und inklusive:
+ * ein Abgleich mit dem groessten gesehenen `updatedAt` als naechstem
+ * `updatedSince` ist lueckenlos (der Eintrag an der Grenze kommt noch einmal).
+ */
+export interface StocktakeListQuery {
+    status?: StocktakeStatus;
+    locationId?: string;
+    updatedSince?: string | Date;
+    /** 1–200, Vorgabe des Servers 50. */
+    limit?: number;
+    cursor?: string;
+}
+export interface StocktakePage {
+    stocktakes: Stocktake[];
+    nextCursor: string | null;
+}
+/** Positionen nach Kennung; `openOnly` = ungezaehlt (in der Pruefung: zum Nachzaehlen offen). */
+export interface StocktakeItemListQuery {
+    stocktakeId: string;
+    openOnly?: boolean;
+    limit?: number;
+    cursor?: string;
+}
+export interface StocktakeItemPage {
+    items: StocktakeItem[];
+    nextCursor: string | null;
+}
+/** Zaehlungen, neueste zuerst; mit `articleId` nur die des Artikels. */
+export interface StocktakeCountListQuery {
+    stocktakeId: string;
+    articleId?: string;
+    limit?: number;
+    cursor?: string;
+}
+export interface StocktakeCountPage {
+    counts: StocktakeCount[];
+    nextCursor: string | null;
+}
+/**
+ * Eine Zaehlung. Menge in Tausendstel (`0` = leer gezaehlt; Stueckartikel und
+ * Einzelstuecke nur ganze Stueck), Einzelstueck mit je Stueck genau einer
+ * Seriennummer. Mehrere Zaehlungen derselben Position werden addiert.
+ */
+export interface RecordStocktakeCountRequest {
+    idempotencyKey: string;
+    stocktakeId: string;
+    articleId: string;
+    /** Vorgabe `sellable`. */
+    condition?: StockCondition;
+    quantity: number;
+    serialNumbers?: string[];
+    /** Hoechstens 200 Zeichen. */
+    note?: string | null;
+}
+/** Storniert eine Zaehlung; die Position wird neu summiert. */
+export interface VoidStocktakeCountRequest {
+    idempotencyKey: string;
+    stocktakeId: string;
+    countId: string;
+    /** 1–500 Zeichen. */
+    reason: string;
+}
+/** Pruefen: `counting` → `review` (bzw. in `review` neu rechnen, etwa nach dem Nachzaehlen). */
+export interface ReviewStocktakeRequest {
+    idempotencyKey: string;
+    stocktakeId: string;
+}
+/** Nachzaehlen in `review`: je Position eine neue Runde; danach erneut pruefen. */
+export interface RecountStocktakeRequest {
+    idempotencyKey: string;
+    stocktakeId: string;
+    /** 1–200 Positionen. */
+    items: Array<{
+        articleId: string;
+        condition?: StockCondition;
+    }>;
+    /** 1–500 Zeichen. */
+    reason: string;
+}
+/** Abschliessen (nur aus `review`); `uncountedAsZero` bucht Ungezaehltes als 0. */
+export interface CloseStocktakeRequest {
+    idempotencyKey: string;
+    stocktakeId: string;
+    /** Vorgabe `false`: Ungezaehltes wird nicht gebucht. */
+    uncountedAsZero?: boolean;
+}
+/**
+ * Antwort von `closeStocktake`: der Kopf (meist `closing`, der Server bucht
+ * im Hintergrund weiter) und Hinweise wie `recount_uncounted`.
+ */
+export interface CloseStocktakeResult {
+    stocktake: Stocktake;
+    /** Leer, wenn es keinen Hinweis gibt. */
+    warnings: StocktakeWarning[];
+}
+/** Abbrechen (aus `counting` oder `review`); der Standort ist danach wieder frei. */
+export interface CancelStocktakeRequest {
+    idempotencyKey: string;
+    stocktakeId: string;
+    /** 1–500 Zeichen. */
+    reason: string;
+}
+/**
+ * Lese-Link auf das Inventurprotokoll, wenn es zu gross fuer die Antwort ist
+ * (ueber 9 MiB). Signiert, 15 Minuten gueltig; die geladene Datei an
+ * `sha256` pruefen.
+ */
+export interface StocktakePdfDownload {
+    url: string;
+    expiresAt: string;
+    sizeBytes: number;
+    /** SHA-256 der Datei, hexadezimal (dieselbe wie `pdf.valuesSha256` bzw. `pdf.quantitiesSha256`). */
+    sha256: string;
+    fileName: string | null;
+    contentType: string | null;
+}
+/**
+ * Das Inventurprotokoll: als Datei (`kind: 'pdf'`) oder, ueber 9 MiB, als
+ * Lese-Link (`kind: 'download'`). Mit `lagerApi.kosten` die Fassung mit
+ * Werten, sonst die nur mit Mengen.
+ */
+export type StocktakePdf = {
+    kind: 'pdf';
+    pdf: Uint8Array;
+} | {
+    kind: 'download';
+    download: StocktakePdfDownload;
+};

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

@@ -1,18 +1,20 @@
 /**
  * Der Vertrag der Lager-API (Backend Stufe 5a lesen, 5b schreiben und
- * reservieren, 5c Varianten) als Daten: Endpunkte, Wertkataloge, Ereignisse, Fehler- und
- * Hinweiscodes, englisch wie am Draht `/v3`.
+ * reservieren, 5c Varianten, Lager-Kern Stufe 3 Inventur) als Daten:
+ * Endpunkte, Wertkataloge, Ereignisse, Fehler- und Hinweiscodes, englisch wie
+ * am Draht `/v3`.
  *
  * Quelle ist der Vertrags-Export des Backends (`fixtures/v3/v3-vokabular.json`):
  * `endpoints.public`, die Kataloge `STANDORT_TYP`, `BEWEGUNG_ART`,
  * `BEWEGUNG_QUELLE`, `LAGER_ZUSTAND`, `LAGER_URSACHE`, `ZUSTELLUNG`,
  * `LAGER_ABGANG_GRUND`, `LAGER_ENTNAHME_ART`, `LAGER_NEBENKOSTEN_ART`,
- * `LAGER_VERTEILUNG`, `RESERVIERUNG_STATUS`, dazu `events`, `errorCodes.inventory`
+ * `LAGER_VERTEILUNG`, `RESERVIERUNG_STATUS`, die Inventur-Kataloge `INVENTUR_*`,
+ * dazu `events`, `errorCodes.inventory`
  * und `warningCodes.inventory`. `test/inventory.test.ts` haelt jede Liste
  * deckungsgleich mit dieser Datei; nichts hier wird geraten.
  */
-/** Die 32 Endpunkte (14 aus 5a, 13 aus 5b, 5 aus 5c), in der Reihenfolge von `endpoints.public`. */
-export declare const INVENTORY_ENDPOINTS: readonly ["getArticle", "listArticles", "lookupArticleByCode", "listLocations", "getStock", "listStock", "listStockMovements", "createWebhook", "updateWebhook", "deleteWebhook", "listWebhooks", "sendWebhookTest", "rotateWebhookSecret", "listWebhookDeliveries", "createArticle", "updateArticle", "deactivateArticle", "receiveGoods", "transferStock", "recordStockLoss", "changeStockCondition", "reverseStockMovement", "createReservation", "extendReservation", "releaseReservation", "getReservation", "listReservations", "createVariantGroup", "updateVariantGroup", "getVariantGroup", "listVariantGroups", "addVariant"];
+/** Die 44 Endpunkte (14 aus 5a, 13 aus 5b, 5 aus 5c, 12 der Inventur), in der Reihenfolge von `endpoints.public`. */
+export declare const INVENTORY_ENDPOINTS: readonly ["getArticle", "listArticles", "lookupArticleByCode", "listLocations", "getStock", "listStock", "listStockMovements", "createWebhook", "updateWebhook", "deleteWebhook", "listWebhooks", "sendWebhookTest", "rotateWebhookSecret", "listWebhookDeliveries", "createArticle", "updateArticle", "deactivateArticle", "receiveGoods", "transferStock", "recordStockLoss", "changeStockCondition", "reverseStockMovement", "createReservation", "extendReservation", "releaseReservation", "getReservation", "listReservations", "createVariantGroup", "updateVariantGroup", "getVariantGroup", "listVariantGroups", "addVariant", "createStocktake", "listStocktakes", "getStocktake", "listStocktakeItems", "recordStocktakeCount", "voidStocktakeCount", "listStocktakeCounts", "reviewStocktake", "recountStocktake", "closeStocktake", "cancelStocktake", "getStocktakePdf"];
 export type InventoryEndpoint = (typeof INVENTORY_ENDPOINTS)[number];
 /** Art eines Standorts (Katalog `STANDORT_TYP`). */
 export declare const LOCATION_TYPES: readonly ["warehouse", "store", "vehicle", "other"];
@@ -98,8 +100,24 @@ export declare const INVENTORY_LIST_LIMIT_MAX = 200;
  * `too_many_positions` traegt bei Varianten `field` (`variants`,
  * `createMatrix` bzw. `externalIds` bei `addVariant`): die Anfrage braeuchte
  * mehr Schreibvorgaenge, als in einen Vorgang passen; geschrieben wurde nichts.
+ *
+ * Seit 1.8.0 dahinter die Codes der Inventur: `stocktake_not_found`,
+ * `stocktake_not_open` (Zaehlen oder Stornieren ausserhalb der Zaehlung bzw.
+ * an einer Position, die nicht zum Nachzaehlen frei ist), `stocktake_closed`
+ * (abgeschlossen oder abgebrochen: nichts mehr schreibbar),
+ * `stocktake_not_in_review` (Nachzaehlen und Abschluss nur in `review`),
+ * `stocktake_closing` (der Abschluss bucht gerade), `stocktake_location_busy`
+ * (am Standort laeuft schon eine Inventur; `data.stocktakeId` nennt sie),
+ * `stocktake_review_running` (die Pruefung rechnet noch), `stocktake_recount_open`
+ * (Abschluss, solange Positionen zum Nachzaehlen offen sind: erst nachzaehlen,
+ * dann erneut pruefen), `article_not_in_scope`, `article_not_tracked`,
+ * `count_not_found`, `count_already_voided`, `serial_already_counted` (dieselbe
+ * Seriennummer zweimal in einer Runde), `too_many_counts` (mehr als
+ * [STOCKTAKE_COUNTS_PER_ITEM_MAX] Zaehlungen je Position und Runde) und
+ * `stocktake_not_closed` (das Protokoll gibt es erst nach dem Abschluss, auch
+ * nicht fuer eine abgebrochene Inventur).
  */
-export declare const INVENTORY_ERROR_CODES: readonly ["validation", "invalid_cursor", "article_not_found", "webhook_not_found", "webhook_limit", "invalid_webhook_url", "event_not_subscribed", "webhook_inactive", "inventory_api_not_enabled", "module_inactive", "rate_limited", "server_error", "idempotency_key_required", "idempotency_conflict", "location_not_found", "location_inactive", "invalid_location", "invalid_locations", "invalid_transfer", "operation_not_found", "already_reversed", "reversal_not_possible", "reversal_not_supported", "exceeds_stock", "no_positions", "too_many_positions", "invalid_step", "invalid_quantity", "invalid_amount", "invalid_price", "negative_value", "invalid_reason", "note_required", "withdrawal_type_required", "invalid_method", "invalid_stock_kind", "invalid_minimum", "invalid_dimensions", "weight_missing", "invalid_landed_cost", "invalid_distribution", "landed_costs_mismatch", "return_totals_mismatch", "lot_not_found", "invalid_serial", "serial_required", "serial_not_allowed", "serial_already_exists", "serial_not_in_stock", "code_taken", "external_id_taken", "group_not_found", "revenue_group_not_found", "stock_kind_locked", "article_inactive", "invalid_position", "invalid_condition", "reason_required", "insufficient_available", "reservation_not_found", "reservation_not_active", "variant_group_not_found", "variant_already_exists", "invalid_variant_attributes", "variant_group_inactive", "variant_limit"];
+export declare const INVENTORY_ERROR_CODES: readonly ["validation", "invalid_cursor", "article_not_found", "webhook_not_found", "webhook_limit", "invalid_webhook_url", "event_not_subscribed", "webhook_inactive", "inventory_api_not_enabled", "module_inactive", "rate_limited", "server_error", "idempotency_key_required", "idempotency_conflict", "location_not_found", "location_inactive", "invalid_location", "invalid_locations", "invalid_transfer", "operation_not_found", "already_reversed", "reversal_not_possible", "reversal_not_supported", "exceeds_stock", "no_positions", "too_many_positions", "invalid_step", "invalid_quantity", "invalid_amount", "invalid_price", "negative_value", "invalid_reason", "note_required", "withdrawal_type_required", "invalid_method", "invalid_stock_kind", "invalid_minimum", "invalid_dimensions", "weight_missing", "invalid_landed_cost", "invalid_distribution", "landed_costs_mismatch", "return_totals_mismatch", "lot_not_found", "invalid_serial", "serial_required", "serial_not_allowed", "serial_already_exists", "serial_not_in_stock", "code_taken", "external_id_taken", "group_not_found", "revenue_group_not_found", "stock_kind_locked", "article_inactive", "invalid_position", "invalid_condition", "reason_required", "insufficient_available", "reservation_not_found", "reservation_not_active", "variant_group_not_found", "variant_already_exists", "invalid_variant_attributes", "variant_group_inactive", "variant_limit", "stocktake_not_found", "stocktake_not_open", "stocktake_closed", "stocktake_not_in_review", "stocktake_closing", "stocktake_location_busy", "stocktake_review_running", "stocktake_recount_open", "article_not_in_scope", "article_not_tracked", "count_not_found", "count_already_voided", "serial_already_counted", "too_many_counts", "stocktake_not_closed"];
 export type InventoryErrorCode = (typeof INVENTORY_ERROR_CODES)[number];
 /**
  * Codes, die Anmeldung und Rand auf jedem Lager-Aufruf erzeugen koennen,
@@ -108,7 +126,7 @@ export type InventoryErrorCode = (typeof INVENTORY_ERROR_CODES)[number];
  * `route_missing` (Code des Pakets). Dieselbe Ableitung wie bei der
  * Rechnungs-API.
  */
-export declare const INVENTORY_REQUEST_ERROR_CODES: readonly ["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"];
+export declare const INVENTORY_REQUEST_ERROR_CODES: readonly ["account_not_found", "admin_required", "api_not_approved", "app_check_invalid", "app_check_missing", "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"];
 export type InventoryRequestErrorCode = (typeof INVENTORY_REQUEST_ERROR_CODES)[number];
 /**
  * Hinweise einer Buchung (`warnings[].code`, `warningCodes.inventory`). Sie sind
@@ -117,8 +135,16 @@ export type InventoryRequestErrorCode = (typeof INVENTORY_REQUEST_ERROR_CODES)[n
  * `below_minimum` misst am verfuegbaren Bestand (`onHand − reserved`) gegen den
  * Mindestbestand des Standorts, `reservation_exceeded` meldet eine Rechnung, die
  * mehr verkauft als reserviert war.
+ *
+ * Seit 1.8.0 die Hinweise der Inventur, je mit der Zahl der Positionen
+ * (`items`): `defect_capped` (eine Fehlmenge im Zustand `defective` reichte
+ * ueber den Defektbestand, der Rest blieb ungebucht), `uncounted_items` (nicht
+ * gezaehlt und darum nicht gebucht), `not_booked` (nicht oder nicht ganz
+ * gebucht, Grund an der Position, `notBooked`) und `recount_uncounted`
+ * (Positionen zum Nachzaehlen blieben ungezaehlt; die Antwort von
+ * `closeStocktake` traegt ihn).
  */
-export declare const INVENTORY_WARNING_CODES: readonly ["insufficient_stock", "below_minimum", "return_exceeds_sale", "reservation_exceeded"];
+export declare const INVENTORY_WARNING_CODES: readonly ["insufficient_stock", "below_minimum", "return_exceeds_sale", "reservation_exceeded", "defect_capped", "uncounted_items", "not_booked", "recount_uncounted"];
 export type InventoryWarningCode = (typeof INVENTORY_WARNING_CODES)[number];
 /**
  * Bestandsart eines Artikels (`stockKind`): `quantity` = Menge, `serial` =
@@ -169,3 +195,63 @@ export declare const VARIANT_ATTRIBUTES_MAX = 3;
 export declare const VARIANT_VALUES_MAX = 30;
 export declare const VARIANT_MATRIX_MAX = 100;
 export declare const VARIANT_GROUP_ACTIVE_MAX = 250;
+/**
+ * Stand einer Inventur (Katalog `INVENTUR_STATUS`). Gezaehlt wird in
+ * `counting`; `review` rechnet Soll und Differenz (erst ab hier sichtbar,
+ * blind); `closing` bucht den Abschluss in Teilen; `closed` und `cancelled`
+ * sind endgueltig. `creating` steht nur, solange eine grosse Anlage ihre
+ * Positionen schreibt.
+ */
+export declare const STOCKTAKE_STATUSES: readonly ["creating", "counting", "review", "closing", "closed", "cancelled"];
+export type StocktakeStatus = (typeof STOCKTAKE_STATUSES)[number];
+/**
+ * Art einer Inventur (Katalog `INVENTUR_ART`): `key_date` zu einem Stichtag
+ * (`keyDate`), `perpetual` (permanente Inventur, ohne Stichtag).
+ */
+export declare const STOCKTAKE_TYPES: readonly ["key_date", "perpetual"];
+export type StocktakeType = (typeof STOCKTAKE_TYPES)[number];
+/** Umfang einer Inventur (Katalog `INVENTUR_UMFANG`): alle bestandsgefuehrten Artikel des Standorts, Artikelgruppen oder genannte Artikel. */
+export declare const STOCKTAKE_SCOPE_TYPES: readonly ["all", "groups", "articles"];
+export type StocktakeScopeType = (typeof STOCKTAKE_SCOPE_TYPES)[number];
+/**
+ * Warum eine Position in der Pruefung „pruefen“ traegt (Katalog
+ * `INVENTUR_PRUEFGRUND`): Bewegung zwischen der ersten und letzten Zaehlung,
+ * Zaehlung mehr als 10 Tage vom Stichtag, Seriennummern weichen ab, nicht gezaehlt.
+ */
+export declare const STOCKTAKE_CHECK_REASONS: readonly ["movements_between_counts", "far_from_key_date", "serial_mismatch", "not_counted"];
+export type StocktakeCheckReason = (typeof STOCKTAKE_CHECK_REASONS)[number];
+/**
+ * Warum eine Position nicht oder nicht ganz gebucht wurde (`notBooked.code`,
+ * Katalog `INVENTUR_NICHT_GEBUCHT`). Dazu kommen Codes, die schon englisch
+ * sind (`serial_not_in_stock`, `serial_already_exists`, `article_not_found`);
+ * das Modell laesst darum jeden Text stehen.
+ */
+export declare const STOCKTAKE_NOT_BOOKED_REASONS: readonly ["serial_mismatch", "recount_open", "defect_capped"];
+export type StocktakeNotBookedReason = (typeof STOCKTAKE_NOT_BOOKED_REASONS)[number];
+/** Woher eine Zaehlung bzw. Inventur kam (Katalog `INVENTUR_QUELLE`). */
+export declare const STOCKTAKE_SOURCES: readonly ["register", "panel", "api"];
+export type StocktakeSource = (typeof STOCKTAKE_SOURCES)[number];
+/** Wer handelte (Katalog `INVENTUR_AKTEUR`): Inhaber, Kasseneck-Admin, Kassen-Benutzer, API-Schluessel. */
+export declare const STOCKTAKE_ACTOR_TYPES: readonly ["owner", "admin", "register_user", "api"];
+export type StocktakeActorType = (typeof STOCKTAKE_ACTOR_TYPES)[number];
+/**
+ * Zu welchem Zeitpunkt das Inventar im Protokoll steht (Katalog
+ * `INVENTUR_INVENTAR_ZUM`): `key_date` (auf das Ende des Stichtags
+ * fortgeschrieben, Abschluss nach dem Stichtag) oder `count_date` (Menge zur
+ * Aufnahme: permanente Inventur oder Abschluss vor dem Stichtag).
+ */
+export declare const STOCKTAKE_INVENTORY_AS_OF: readonly ["key_date", "count_date"];
+export type StocktakeInventoryAsOf = (typeof STOCKTAKE_INVENTORY_AS_OF)[number];
+/**
+ * Grenzen einer Inventur, wie das Backend sie prueft. Wie bei den Varianten
+ * prueft das Paket sie **nicht** vor dem Senden:
+ *
+ * - [STOCKTAKE_ITEMS_MAX] Positionen je Inventur (`too_many_positions`;
+ *   groessere Bestaende in mehreren Inventuren nacheinander),
+ * - [STOCKTAKE_RECOUNT_ITEMS_MAX] Positionen je `recountStocktake`,
+ * - [STOCKTAKE_COUNTS_PER_ITEM_MAX] Zaehlungen je Position und Runde
+ *   (`too_many_counts`), hoechstens so viele Seriennummern je Zaehlung.
+ */
+export declare const STOCKTAKE_ITEMS_MAX = 5000;
+export declare const STOCKTAKE_RECOUNT_ITEMS_MAX = 200;
+export declare const STOCKTAKE_COUNTS_PER_ITEM_MAX = 200;