@kreiseck/kasseneck-api 1.4.0 → 1.5.1

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 { InventoryWebhookEventType, LocationType, StockChangeCause, StockCondition, StockMovementSource, StockMovementType, WebhookDeliveryStatus } from './vertrag.js';
+import type { InventoryWarningCode, InventoryWebhookEventType, LandedCostAllocation, LandedCostType, LocationType, ReservationStatus, StockChangeCause, StockCondition, StockKind, StockLossReason, StockMovementSource, StockMovementType, WebhookDeliveryStatus, WithdrawalType } from './vertrag.js';
 /**
  * Ein Artikel, wie `getArticle`, `listArticles`, `lookupArticleByCode` und die
  * Ereignisse `article.*` ihn senden.
@@ -24,6 +24,8 @@ import type { InventoryWebhookEventType, LocationType, StockChangeCause, StockCo
 export interface Article {
     id: string;
     name: string | null;
+    /** Beschreibung (bis 2000 Zeichen); `null` = keine. Seit 1.5.0. */
+    description: string | null;
     unitPriceCents: number | null;
     /** USt-Satz in Prozent, z. B. `20`, `10`, `4.9`. */
     vatRate: number | null;
@@ -34,14 +36,26 @@ export interface Article {
     groupId: string | null;
     revenueGroupId: string | null;
     stockTracked: boolean;
+    /**
+     * `quantity` (Menge) oder `serial` (Einzelstueck); `null`, wenn der Server
+     * das Feld nicht sendet (vor Stufe 5b). Ein Wert, den diese Paketversion
+     * nicht kennt, bleibt als Text stehen. Seit 1.5.0.
+     */
+    stockKind: StockKind | (string & {}) | null;
     /** Standorte, an denen der Artikel gefuehrt wird; leer = nur der Standard-Standort. */
     stockLocationIds: string[];
     /**
-     * Mindestbestand des Artikels in Tausendstel; `null` = keiner. Warnungen,
-     * `belowMinimum` und `stock.below_minimum` richten sich nach dem Mindestbestand je
-     * Standort, nicht nach diesem Wert.
+     * **Altfeld.** Mindestbestand des Artikels in Tausendstel; `null` = keiner.
+     * Er loest nichts aus: Warnungen, `belowMinimum` und `stock.below_minimum`
+     * richten sich nach [minStockByLocation].
      */
     minStock: number | null;
+    /**
+     * Mindestbestand je Standort in Tausendstel (`{ haupt: 20000 }`), die
+     * Schwelle fuer `below_minimum`, gemessen am verfuegbaren Bestand
+     * (`onHand − reserved`). Leer = keiner. Seit 1.5.0.
+     */
+    minStockByLocation: Record<string, number>;
     active: boolean;
     externalIds?: Record<string, string>;
     metadata?: Record<string, string>;
@@ -138,8 +152,9 @@ export interface StockListQuery {
     locationId?: string;
     articleId?: string;
     /**
-     * `true`: nur Zeilen, deren `onHand` unter dem Mindestbestand ihres Standorts liegt
-     * (dieselbe Regel wie `stock.below_minimum`; `minStock` des Artikels zaehlt nicht).
+     * `true`: nur Zeilen, deren verfuegbarer Bestand (`available = onHand − reserved`)
+     * unter dem Mindestbestand ihres Standorts liegt (dieselbe Regel wie
+     * `stock.below_minimum`; `minStock` des Artikels zaehlt nicht).
      */
     belowMinimum?: boolean;
     /** Nur Zeilen, die sich seitdem geaendert haben (inklusive), nach `updatedAt` aufsteigend. */
@@ -176,12 +191,21 @@ export interface StockMovement {
     articleId: string | null;
     locationId: string | null;
     condition: StockCondition | (string & {}) | null;
-    /** Mengenaenderung in Tausendstel (Abgang negativ). */
+    /** Mengenaenderung in Tausendstel (Abgang negativ); bei `reservation` immer 0. */
     quantityDelta: number;
-    /** Bestand am Standort nach der Bewegung. */
+    /**
+     * Aenderung von `reserved` in Tausendstel: positiv beim Reservieren, negativ
+     * bei Freigabe, Ablauf und Einloesen; 0 bei allen anderen Bewegungen. Seit 1.5.0.
+     */
+    reservedDelta: number;
+    /**
+     * Bestand am Standort nach der Bewegung. `reserved` steht nur an
+     * Reservierungsbewegungen, sonst `null` (nicht erfasst, nicht „0“).
+     */
     stockAfter: {
         sellable: number;
         defective: number;
+        reserved: number | null;
     } | null;
     operationId: string | null;
     source: StockMovementSourceRef | null;
@@ -294,10 +318,12 @@ export interface StockChangedEventData extends StockLevel {
 export interface StockBelowMinimumEventData {
     articleId: string;
     locationId: string;
+    /** Verfuegbarer Bestand (`onHand − reserved`); eine Reservierung allein kann ausloesen. */
     available: number;
     /**
-     * Der Mindestbestand des Standorts in Tausendstel – die unterschrittene Schwelle,
-     * gemessen am Bestand `onHand`. Der `minStock` des Artikels allein loest nie aus.
+     * Der Mindestbestand des Standorts in Tausendstel (`minStockByLocation`) –
+     * die unterschrittene Schwelle, gemessen an `available`. Der `minStock` des
+     * Artikels allein loest nie aus.
      */
     minStock: number;
 }
@@ -316,4 +342,338 @@ export interface InventoryWebhookEnvelope<T extends InventoryWebhookEventType, D
     test: boolean;
     data: D;
 }
-export type InventoryWebhookEvent = InventoryWebhookEnvelope<'stock.changed', StockChangedEventData> | InventoryWebhookEnvelope<'stock.below_minimum', StockBelowMinimumEventData> | InventoryWebhookEnvelope<'article.created', Article> | InventoryWebhookEnvelope<'article.updated', Article> | InventoryWebhookEnvelope<'article.deactivated', Article>;
+export type InventoryWebhookEvent = InventoryWebhookEnvelope<'stock.changed', StockChangedEventData> | InventoryWebhookEnvelope<'stock.below_minimum', StockBelowMinimumEventData> | InventoryWebhookEnvelope<'article.created', Article> | InventoryWebhookEnvelope<'article.updated', Article> | InventoryWebhookEnvelope<'article.deactivated', Article> | InventoryWebhookEnvelope<'reservation.expired', Reservation> | InventoryWebhookEnvelope<'reservation.released', Reservation> | InventoryWebhookEnvelope<'reservation.redeemed', Reservation>;
+/**
+ * Die Felder eines Artikels beim Anlegen. Bei der Anlage heisst `null` „nicht
+ * angegeben“ (ausser bei `name`, der Pflicht ist).
+ */
+export interface ArticleInput {
+    /** 1–200 Zeichen, getrimmt gespeichert. */
+    name: string;
+    /** Bis 2000 Zeichen. */
+    description?: string | null;
+    unitPriceCents?: number | null;
+    /** USt-Satz in Prozent (`20`, `13`, `10`, `4.9`, `0`, `19`). */
+    vatRate?: number | null;
+    /** 1–20 Zeichen; ohne Angabe die Vorgabe des Kontos. */
+    unit?: string | null;
+    /** Artikelnummer, 1–64 Zeichen. */
+    number?: string | null;
+    /**
+     * GTIN/EAN mit gueltiger Pruefziffer: der Artikel wird ein Fremdartikel mit
+     * diesem Code. Ohne `ean` vergibt der Server einen eigenen Code nach den
+     * Einstellungen des Kontos (`internalCode`). Ein Code, der schon einem
+     * anderen Artikel gehoert, ergibt `code_taken`.
+     */
+    ean?: string | null;
+    /** Artikelgruppe; unbekannt = `group_not_found`. */
+    groupId?: string | null;
+    /** Erloesgruppe; unbekannt = `revenue_group_not_found`. */
+    revenueGroupId?: string | null;
+    stockTracked?: boolean | null;
+    /** Hoechstens 50 Standorte; unbekannt = `location_not_found`. */
+    stockLocationIds?: string[] | null;
+    /** **Altfeld** ohne Wirkung auf Meldungen; Tausendstel in ganzen Einheiten (Vielfaches von 1000). */
+    minStock?: number | null;
+    /** Mindestbestand je Standort in Tausendstel, hoechstens 50 Standorte. */
+    minStockByLocation?: Record<string, number | null> | null;
+    stockKind?: StockKind | null;
+    /**
+     * Standard-Einkaufspreis je Basiseinheit in Mikro-Euro. Nur mit dem
+     * Konto-Recht `costs`, sonst `inventory_api_not_enabled` mit
+     * `errors: [{ field: 'purchasePriceMicros' }]`.
+     */
+    purchasePriceMicros?: number | null;
+    /**
+     * Eigene Kennungen je System (`{ shop: '1001' }`): hoechstens 10 Systeme
+     * `^[a-z0-9_]{1,32}$`, Werte 1–128 Zeichen, je System und Wert eindeutig im
+     * Konto (`external_id_taken`). Damit findet `lookupArticleByCode` den Artikel.
+     */
+    externalIds?: Record<string, string> | null;
+    /** Freie Merkmale, nie ausgewertet: hoechstens 20 Schluessel `^[a-zA-Z0-9_]{1,40}$`, Werte bis 500 Zeichen, zusammen 4 KB. */
+    metadata?: Record<string, string> | null;
+}
+export interface CreateArticleRequest extends ArticleInput {
+    idempotencyKey: string;
+}
+/**
+ * Eine Aenderung: nur die genannten Felder, mindestens eines. `null` leert ein
+ * optionales Feld (`description`, `unitPriceCents`, `vatRate`, `number`,
+ * `groupId`, `revenueGroupId`, `minStock`, `stockLocationIds`, `externalIds`,
+ * `metadata`, `minStockByLocation`, `purchasePriceMicros`). `name`, `unit`,
+ * `ean`, `stockTracked` und `stockKind` lassen sich nicht leeren.
+ *
+ * `externalIds` und `metadata` werden ganz ersetzt, `minStockByLocation` je
+ * Standort zusammengefuehrt (`{ haupt: null }` nimmt nur diesen Standort weg).
+ * Die EAN laesst sich nur bei Fremdartikeln wechseln; `stockKind` nach der
+ * ersten Bewegung nicht mehr (`stock_kind_locked`). Ein stillgelegter Artikel
+ * ergibt `article_inactive`.
+ */
+export interface UpdateArticleRequest {
+    idempotencyKey: string;
+    articleId: string;
+    name?: string;
+    description?: string | null;
+    unitPriceCents?: number | null;
+    vatRate?: number | null;
+    unit?: string;
+    number?: string | null;
+    ean?: string;
+    groupId?: string | null;
+    revenueGroupId?: string | null;
+    stockTracked?: boolean;
+    stockLocationIds?: string[] | null;
+    minStock?: number | null;
+    minStockByLocation?: Record<string, number | null> | null;
+    stockKind?: StockKind;
+    purchasePriceMicros?: number | null;
+    externalIds?: Record<string, string> | null;
+    metadata?: Record<string, string> | null;
+}
+/**
+ * Stilllegen: `active: false`; Code und eigene Kennungen werden frei. Schon
+ * stillgelegt = dieselbe Antwort, nichts geschrieben. Den Bestand behaelt der
+ * Artikel, gebucht werden darf weiter.
+ */
+export interface DeactivateArticleRequest {
+    idempotencyKey: string;
+    articleId: string;
+}
+/** Ein Hinweis einer Buchung: sie hat gewirkt, es gibt nur etwas zu wissen. */
+export interface InventoryWarning {
+    code: InventoryWarningCode | (string & {});
+    articleId: string | null;
+    locationId: string | null;
+    /** Fuer Menschen, deutsch; nie darauf verzweigen. */
+    message: string;
+}
+/**
+ * Antwort jeder Buchung (`receiveGoods`, `transferStock`, `recordStockLoss`,
+ * `changeStockCondition`, `reverseStockMovement`). Werte traegt sie nie. Eine
+ * Wiederholung mit demselben `idempotencyKey` liefert genau diese Antwort
+ * noch einmal (ohne Kennzeichen, die beiden sind gleich).
+ */
+export interface StockOperation {
+    /** Kennung des Vorgangs; `reverseStockMovement` nimmt ihn zurueck. */
+    operationId: string;
+    movementIds: string[];
+    lotIds: string[];
+    warnings: InventoryWarning[];
+}
+/** Eine Position eines Wareneingangs. */
+export interface GoodsReceiptItem {
+    articleId: string;
+    /** Tausendstel, groesser als 0. */
+    quantity: number;
+    /** Gesamtpreis der Position in Cent. Entweder dieser oder `unitPriceMicros`; ohne beide der Einkaufspreis des Artikels. */
+    totalCents?: number;
+    /** Einzelpreis je Basiseinheit in Mikro-Euro. */
+    unitPriceMicros?: number;
+    /** Nebenkosten dieser Position in Cent; gilt nur bei `allocation: 'manual'`. */
+    landedCostCents?: number;
+    /** Ablaufdatum `YYYY-MM-DD`. */
+    expiresOn?: string;
+    /** Charge, 1–64 Zeichen. */
+    batch?: string;
+    /** Seriennummern (Einzelstuecke), hoechstens 80, je 1–128 Zeichen. */
+    serialNumbers?: string[];
+}
+export interface LandedCost {
+    type: LandedCostType;
+    /** Betrag in Cent; `discount` und `cash_discount` mindern den Wert. */
+    amountCents: number;
+}
+/**
+ * Wareneingang. Preise und Nebenkosten darf jeder Schreibende senden (so
+ * bekommt der Bestand seinen Wert); zurueck kommen Werte nur mit dem Recht
+ * `costs` und nur in der Vorschau ([previewGoodsReceipt]).
+ */
+export interface ReceiveGoodsRequest {
+    idempotencyKey: string;
+    /** Hoechstens 80 Positionen (`too_many_positions`). */
+    items: GoodsReceiptItem[];
+    /** Ohne Angabe der Standard-Standort des Kontos. */
+    locationId?: string;
+    /** Hoechstens 20. */
+    landedCosts?: LandedCost[];
+    allocation?: LandedCostAllocation;
+    supplier?: {
+        name: string;
+        address?: string;
+    };
+    /** Lieferschein o. Ae., 1–80 Zeichen. */
+    reference?: string;
+    /** 1–500 Zeichen. */
+    note?: string;
+}
+/**
+ * Vorschau eines Wareneingangs (`dryRun: true`): schreibt nichts, der
+ * Schluessel ist freigestellt (wenn da, wird nur seine Form geprueft), das
+ * Schreibrecht braucht sie trotzdem. Den Standort prueft erst die Buchung.
+ */
+export type GoodsReceiptPreviewRequest = Omit<ReceiveGoodsRequest, 'idempotencyKey'> & {
+    idempotencyKey?: string;
+};
+/**
+ * Eine Zeile der Vorschau. Die vier Werte (`baseCents`, `landedCostCents`,
+ * `valueCents`, `unitCostMicros`) kommen nur mit dem Recht `costs` und fehlen
+ * sonst ganz.
+ */
+export interface GoodsReceiptPreviewLine {
+    articleId: string;
+    quantity: number;
+    expiresOn: string | null;
+    batch: string | null;
+    serialNumbers: string[];
+    /** `true`: der Preis kam aus dem Artikel, nicht aus der Anfrage. */
+    priceFromArticle: boolean;
+    baseCents?: number | null;
+    landedCostCents?: number | null;
+    valueCents?: number | null;
+    unitCostMicros?: number | null;
+}
+export interface GoodsReceiptPreview {
+    preview: GoodsReceiptPreviewLine[];
+}
+/** Eine Position von Umbuchung, Abgang oder Zustandswechsel. */
+export interface StockItem {
+    articleId: string;
+    /** Tausendstel, groesser als 0. */
+    quantity: number;
+    /** Bei Einzelstuecken das Stueck. */
+    serialNumber?: string;
+}
+/** Umbuchung zwischen zwei Standorten. Ueberzieht nie (`exceeds_stock`). */
+export interface TransferStockRequest {
+    idempotencyKey: string;
+    fromLocationId: string;
+    toLocationId: string;
+    items: StockItem[];
+    note?: string;
+}
+/**
+ * Abgang (Bruch, Schwund, Entnahme …). Ueberzieht nie (`exceeds_stock`).
+ * `reason: 'other'` braucht `note` (`note_required`), `reason: 'withdrawal'`
+ * braucht `withdrawalType` (`withdrawal_type_required`).
+ */
+export interface RecordStockLossRequest {
+    idempotencyKey: string;
+    reason: StockLossReason;
+    withdrawalType?: WithdrawalType;
+    /** Aus welchem Zustand; Vorgabe `sellable`. */
+    condition?: StockCondition;
+    locationId?: string;
+    items: StockItem[];
+    note?: string;
+}
+/** Ware zwischen verkaufbar und defekt umbuchen. Ueberzieht nie (`exceeds_stock`). */
+export interface ChangeStockConditionRequest {
+    idempotencyKey: string;
+    from: StockCondition;
+    to: StockCondition;
+    locationId?: string;
+    items: StockItem[];
+    note?: string;
+}
+/**
+ * Gegenbuchung: nimmt einen ganzen Vorgang zurueck. Verkaeufe und
+ * Reservierungen gehen so nicht (`reversal_not_supported`), ein zweites Mal
+ * auch nicht (`already_reversed`).
+ */
+export interface ReverseStockMovementRequest {
+    idempotencyKey: string;
+    operationId: string;
+    /** Pflicht, bis 500 Zeichen; leer = `reason_required`. */
+    reason: string;
+}
+/**
+ * Eine Position einer Reservierung, Mengen in Tausendstel. Offen ist
+ * `quantity − redeemed − released`.
+ */
+export interface ReservationItem {
+    articleId: string;
+    locationId: string;
+    quantity: number;
+    redeemed: number;
+    released: number;
+}
+/**
+ * Eine Reservierung, wie `getReservation`, jede schreibende Reservierungs-
+ * Antwort und die Ereignisse `reservation.*` sie senden.
+ */
+export interface Reservation {
+    id: string;
+    /** `null`: ein Stand, den diese Paketversion nicht kennt, oder keiner. */
+    status: ReservationStatus | (string & {}) | null;
+    /** Eigene Referenz (Bestellnummer), `null` = keine. */
+    reference: string | null;
+    items: ReservationItem[];
+    /** Ablauf, ISO 8601 UTC. */
+    expiresAt: string | null;
+    createdAt: string | null;
+}
+export interface ReservationItemInput {
+    articleId: string;
+    /** Tausendstel, groesser als 0. */
+    quantity: number;
+    /** Ohne Angabe der Standard-Standort des Kontos. */
+    locationId?: string;
+}
+/**
+ * Reservieren (Checkout): ganz oder gar nicht. Fehlt verfuegbarer Bestand an
+ * einer Position, entsteht nichts und der Fehler `insufficient_available`
+ * nennt die fehlenden Positionen ([inventoryShortfalls]). Nur
+ * bestandsgefuehrte Artikel. Gleiche Artikel am gleichen Standort werden
+ * zusammengezaehlt.
+ */
+export interface CreateReservationRequest {
+    idempotencyKey: string;
+    /** 1–50 Positionen. */
+    items: ReservationItemInput[];
+    /** 1–128 Zeichen; `listReservations({ reference })` findet sie damit. */
+    reference?: string | null;
+    /** 5 … 43 200 Minuten; ohne Angabe die Vorgabe des Kontos (7 Tage). */
+    expiresInMinutes?: number | null;
+}
+/** Verlaengern: neuer Ablauf = jetzt + Minuten. Nur eine aktive, noch nicht faellige Reservierung (`reservation_not_active`). */
+export interface ExtendReservationRequest {
+    idempotencyKey: string;
+    reservationId: string;
+    /** 5 … 43 200 Minuten. */
+    expiresInMinutes: number;
+}
+export interface ReleaseReservationItem {
+    articleId: string;
+    locationId?: string;
+    /** Ohne Angabe der ganze offene Rest der Position. */
+    quantity?: number;
+}
+/** Freigeben: ohne `items` alles, sonst je Position (ganz oder teilweise). */
+export interface ReleaseReservationRequest {
+    idempotencyKey: string;
+    reservationId: string;
+    /** Nicht leer; ganz weglassen, um alles freizugeben. */
+    items?: ReleaseReservationItem[];
+}
+export interface ReservationListQuery {
+    status?: ReservationStatus;
+    /** Genau diese Referenz. */
+    reference?: string;
+    /** 1–200, Vorgabe des Servers 50. */
+    limit?: number;
+    cursor?: string;
+}
+/** Neueste zuerst (`createdAt` absteigend). */
+export interface ReservationPage {
+    reservations: Reservation[];
+    nextCursor: string | null;
+}
+/** Eine Position, fuer die beim Reservieren der verfuegbare Bestand nicht reicht (`insufficient_available`). */
+export interface InventoryShortfall {
+    articleId: string;
+    locationId: string;
+    /** Angefragt, Tausendstel. */
+    requested: number;
+    /** Verfuegbar (`onHand − reserved`), Tausendstel; darf negativ sein. */
+    available: number;
+}

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

@@ -1,15 +1,18 @@
 /**
- * Der Vertrag der Lager-API (Backend Stufe 5a) als Daten: Endpunkte,
- * Wertkataloge, Ereignisse und Fehlercodes, englisch wie am Draht `/v3`.
+ * Der Vertrag der Lager-API (Backend Stufe 5a lesen, 5b schreiben und
+ * reservieren) 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` und
- * `events`. `test/inventory.test.ts` haelt jede Liste deckungsgleich mit
- * dieser Datei; nichts hier wird geraten.
+ * `BEWEGUNG_QUELLE`, `LAGER_ZUSTAND`, `LAGER_URSACHE`, `ZUSTELLUNG`,
+ * `LAGER_ABGANG_GRUND`, `LAGER_ENTNAHME_ART`, `LAGER_NEBENKOSTEN_ART`,
+ * `LAGER_VERTEILUNG`, `RESERVIERUNG_STATUS`, dazu `events`, `errorCodes.inventory`
+ * und `warningCodes.inventory`. `test/inventory.test.ts` haelt jede Liste
+ * deckungsgleich mit dieser Datei; nichts hier wird geraten.
  */
-/** Die 14 Endpunkte, 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"];
+/** Die 27 Endpunkte (14 aus 5a, 13 aus 5b), 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"];
 export type InventoryEndpoint = (typeof INVENTORY_ENDPOINTS)[number];
 /** Art eines Standorts (Katalog `STANDORT_TYP`). */
 export declare const LOCATION_TYPES: readonly ["warehouse", "store", "vehicle", "other"];
@@ -18,8 +21,10 @@ export type LocationType = (typeof LOCATION_TYPES)[number];
  * Art einer Lagerbewegung (Katalog `BEWEGUNG_ART`); zugleich der Filter `type`.
  * `goods_receipt` ist der Wareneingang, `takeover` der uebernommene Anfangsbestand
  * (auch per Import). `receipt` gibt es hier nicht: das ist der Kassenbeleg (Quelle).
+ * `reservation` (seit 1.5.0) aendert nur `reserved`: `quantityDelta` ist 0, die
+ * Menge steht in `reservedDelta`.
  */
-export declare const STOCK_MOVEMENT_TYPES: readonly ["sale", "goods_receipt", "loss", "return", "transfer_out", "transfer_in", "condition_out", "condition_in", "stocktake", "adjustment", "takeover", "reversal", "revaluation", "method_change"];
+export declare const STOCK_MOVEMENT_TYPES: readonly ["sale", "goods_receipt", "loss", "return", "transfer_out", "transfer_in", "condition_out", "condition_in", "stocktake", "adjustment", "takeover", "reversal", "revaluation", "method_change", "reservation"];
 export type StockMovementType = (typeof STOCK_MOVEMENT_TYPES)[number];
 /**
  * Woher eine Bewegung kommt (Katalog `BEWEGUNG_QUELLE`); zugleich der Filter
@@ -42,10 +47,13 @@ export type StockChangeCause = (typeof STOCK_CHANGE_CAUSES)[number];
 export declare const WEBHOOK_DELIVERY_STATUSES: readonly ["delivered", "pending", "failed", "dropped"];
 export type WebhookDeliveryStatus = (typeof WEBHOOK_DELIVERY_STATUSES)[number];
 /**
- * Die Ereignisse, die ein Konto-Webhook abonnieren kann (Stufe 5a). Spaetere
- * Stufen ergaenzen `reservation.*` und `variant_group.*`.
+ * Die Ereignisse, die ein Konto-Webhook abonnieren kann, in der Reihenfolge von
+ * `listWebhooks().events`. `reservation.*` (seit 1.5.0) tragen die Reservierung
+ * wie `getReservation`, mit dem Status danach: `reservation.released` und
+ * `reservation.redeemed` kommen bei jeder wirksamen Freigabe bzw. Einloesung,
+ * auch einer teilweisen (dann bleibt der Status `active`).
  */
-export declare const INVENTORY_WEBHOOK_EVENTS: readonly ["stock.changed", "stock.below_minimum", "article.created", "article.updated", "article.deactivated"];
+export declare const INVENTORY_WEBHOOK_EVENTS: readonly ["stock.changed", "stock.below_minimum", "article.created", "article.updated", "article.deactivated", "reservation.expired", "reservation.released", "reservation.redeemed"];
 export type InventoryWebhookEventType = (typeof INVENTORY_WEBHOOK_EVENTS)[number];
 /**
  * Die Felder der Huelle jeder Zustellung, in der Reihenfolge am Draht. Statt
@@ -58,12 +66,23 @@ export declare const INVENTORY_WEBHOOK_LIMIT = 5;
 /** Groesstes `limit` einer Liste; ohne Angabe liefert der Server 50. */
 export declare const INVENTORY_LIST_LIMIT_MAX = 200;
 /**
- * Die Codes, die die Lager-Endpunkte selbst senden. `validation` traegt
- * `errors: [{ field, message }]`, `rate_limited` traegt `retryAfterSec`
- * (dazu die Kopfzeile `Retry-After`) – auch bei `sendWebhookTest` nach 20
- * Probesendungen je Wiener Kalendertag (dann bis Mitternacht in Wien).
+ * Die Codes, die die Lager-Endpunkte selbst senden (`errorCodes.inventory`;
+ * `register_user_not_allowed` steht bei [INVENTORY_REQUEST_ERROR_CODES]).
+ * `validation` traegt `errors: [{ field, message }]`, `rate_limited` traegt
+ * `retryAfterSec` (dazu die Kopfzeile `Retry-After`) – auch bei
+ * `sendWebhookTest` nach 20 Probesendungen je Wiener Kalendertag (dann bis
+ * Mitternacht in Wien).
+ *
+ * Seit 1.5.0 hinten angehaengt, in der Reihenfolge des Vertrags: die Codes
+ * der schreibenden Endpunkte. `idempotency_key_required` (Schluessel fehlt),
+ * `idempotency_conflict` (derselbe Schluessel mit anderem Inhalt),
+ * `exceeds_stock` (Abgang, Umbuchung und Zustandswechsel ueberziehen nie),
+ * `insufficient_available` (Reservierung; `data.details[]`, siehe
+ * [inventoryShortfalls]), `code_taken` und `external_id_taken` (mit `field` und
+ * `articleId` des Artikels, dem der Code gehoert), `stock_kind_locked`,
+ * `reservation_not_found`, `reservation_not_active` …
  */
-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"];
+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"];
 export type InventoryErrorCode = (typeof INVENTORY_ERROR_CODES)[number];
 /**
  * Codes, die Anmeldung und Rand auf jedem Lager-Aufruf erzeugen koennen,
@@ -74,3 +93,44 @@ export type InventoryErrorCode = (typeof INVENTORY_ERROR_CODES)[number];
  */
 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 type InventoryRequestErrorCode = (typeof INVENTORY_REQUEST_ERROR_CODES)[number];
+/**
+ * Hinweise einer Buchung (`warnings[].code`, `warningCodes.inventory`). Sie sind
+ * keine Fehler: die Buchung hat gewirkt. `insufficient_stock` gibt es nur beim
+ * Verkauf (Abgang, Umbuchung und Zustandswechsel weisen mit `exceeds_stock` ab),
+ * `below_minimum` misst am verfuegbaren Bestand (`onHand − reserved`) gegen den
+ * Mindestbestand des Standorts, `reservation_exceeded` meldet eine Rechnung, die
+ * mehr verkauft als reserviert war.
+ */
+export declare const INVENTORY_WARNING_CODES: readonly ["insufficient_stock", "below_minimum", "return_exceeds_sale", "reservation_exceeded"];
+export type InventoryWarningCode = (typeof INVENTORY_WARNING_CODES)[number];
+/**
+ * Bestandsart eines Artikels (`stockKind`): `quantity` = Menge, `serial` =
+ * Einzelstueck mit Seriennummer. Kein Katalog des Vokabulars, der Server
+ * uebersetzt das Feld selbst; nach der ersten Bewegung fest (`stock_kind_locked`).
+ */
+export declare const STOCK_KINDS: readonly ["quantity", "serial"];
+export type StockKind = (typeof STOCK_KINDS)[number];
+/** Grund eines Abgangs (`recordStockLoss.reason`, Katalog `LAGER_ABGANG_GRUND`). `other` braucht `note`. */
+export declare const STOCK_LOSS_REASONS: readonly ["breakage", "shrinkage", "theft", "expired", "withdrawal", "disposal", "other"];
+export type StockLossReason = (typeof STOCK_LOSS_REASONS)[number];
+/** Art einer Entnahme (`withdrawalType`, Katalog `LAGER_ENTNAHME_ART`); Pflicht bei `reason: 'withdrawal'`, sonst nicht erlaubt. */
+export declare const WITHDRAWAL_TYPES: readonly ["private", "staff", "gift", "sample"];
+export type WithdrawalType = (typeof WITHDRAWAL_TYPES)[number];
+/** Art von Nebenkosten eines Wareneingangs (`landedCosts[].type`, Katalog `LAGER_NEBENKOSTEN_ART`). */
+export declare const LANDED_COST_TYPES: readonly ["freight", "customs", "insurance", "other", "discount", "cash_discount"];
+export type LandedCostType = (typeof LANDED_COST_TYPES)[number];
+/** Verteilung der Nebenkosten (`allocation`, Katalog `LAGER_VERTEILUNG`); Vorgabe des Servers `value`. */
+export declare const LANDED_COST_ALLOCATIONS: readonly ["value", "quantity", "weight", "manual"];
+export type LandedCostAllocation = (typeof LANDED_COST_ALLOCATIONS)[number];
+/**
+ * Stand einer Reservierung (Katalog `RESERVIERUNG_STATUS`). Nur `active` haelt
+ * Ware zurueck; die drei anderen sind endgueltig: `redeemed` (ueber eine
+ * Rechnung eingeloest), `released` (freigegeben), `expired` (abgelaufen).
+ */
+export declare const RESERVATION_STATUSES: readonly ["active", "redeemed", "released", "expired"];
+export type ReservationStatus = (typeof RESERVATION_STATUSES)[number];
+/** Laengster `idempotencyKey` (Zeichen); laenger weist der Server ab, er schneidet nie ab. */
+export declare const INVENTORY_IDEMPOTENCY_KEY_MAX = 120;
+/** Kuerzeste und laengste Haltedauer einer Reservierung in Minuten (`expiresInMinutes`, 30 Tage). */
+export declare const RESERVATION_MINUTES_MIN = 5;
+export declare const RESERVATION_MINUTES_MAX = 43200;