@kreiseck/kasseneck-api 1.3.0 → 1.4.0

package/dist/esm/inventory/lesen.js

@@ -0,0 +1,278 @@
+/**
+ * Leser der Lager-Antworten: aus dem Draht `/v3` werden die Modelle in
+ * `typen.ts`. Paketintern, nicht Teil der Oberflaeche.
+ *
+ * Regel wie beim Lager an der Kasse (`pos/lager.ts`): eine Menge, ein Betrag
+ * oder eine Folgenummer ist eine Ganzzahl, sonst endet der Aufruf mit
+ * `KasseneckValidationError` (`scope: 'response'`). Ein Ersatzwert wie `0`
+ * waere eine falsche Aussage („kein Bestand“ statt „Antwort kaputt“). Texte
+ * sind nachsichtiger: ein fehlender oder fremder Wert wird `null`.
+ *
+ * Optionale Felder (Einkaufswerte, `externalIds` …) erscheinen im Modell nur,
+ * wenn der Server sie sendet: „fehlt“ heisst dort „kein Recht“, nicht „leer“.
+ */
+import { KasseneckValidationError } from '../client/errors.js';
+import { LOCATION_TYPES } from './vertrag.js';
+const hat = (o, k) => Object.prototype.hasOwnProperty.call(o, k);
+export function antwortfehler(name, grund) {
+    return new KasseneckValidationError(name, grund, 'response');
+}
+export function objekt(w) {
+    return w !== null && typeof w === 'object' && !Array.isArray(w) ? w : null;
+}
+/** Ein Eintrag, der ein Objekt sein muss. */
+function eintrag(ort, w) {
+    const o = objekt(w);
+    if (!o)
+        throw antwortfehler(ort.name, `Antwort ist unbrauchbar (data.${ort.pfad} ist kein Objekt)`);
+    return o;
+}
+const text = (w) => (typeof w === 'string' ? w : null);
+/** Eine Kennung, die da sein muss; ohne sie ist der Eintrag nicht zuzuordnen. */
+function kennung(ort, feld, w) {
+    if (typeof w !== 'string' || w === '') {
+        throw antwortfehler(ort.name, `Antwort enthaelt keine Kennung (data.${ort.pfad}.${feld} fehlt)`);
+    }
+    return w;
+}
+/** Eine Ganzzahl, die da sein muss. */
+function ganzzahl(ort, feld, w) {
+    if (typeof w !== 'number' || !Number.isSafeInteger(w)) {
+        throw antwortfehler(ort.name, `Antwort enthaelt keine ganze Zahl (data.${ort.pfad}.${feld})`);
+    }
+    return w;
+}
+/** Eine Ganzzahl oder `null`; fehlt der Wert, gilt `null`. */
+function ganzzahlOderNull(ort, feld, w) {
+    if (w === undefined || w === null)
+        return null;
+    return ganzzahl(ort, feld, w);
+}
+/** Eine Textabbildung (`externalIds`, `metadata`, `variantAttributes`): nur Texteintraege. */
+function textAbbildung(w) {
+    const o = objekt(w);
+    if (!o)
+        return undefined;
+    const raus = {};
+    for (const [k, v] of Object.entries(o))
+        if (typeof v === 'string')
+            raus[k] = v;
+    return raus;
+}
+// ---- Artikel ------------------------------------------------------------------
+export function artikel(ort, w) {
+    const a = eintrag(ort, w);
+    let standorte = [];
+    if (a.stockLocationIds !== undefined && a.stockLocationIds !== null) {
+        if (!Array.isArray(a.stockLocationIds) || !a.stockLocationIds.every((s) => typeof s === 'string')) {
+            throw antwortfehler(ort.name, `Antwort ist unbrauchbar (data.${ort.pfad}.stockLocationIds ist keine Liste von Kennungen)`);
+        }
+        standorte = [...a.stockLocationIds];
+    }
+    const vatRate = a.vatRate;
+    if (vatRate !== undefined && vatRate !== null && (typeof vatRate !== 'number' || !Number.isFinite(vatRate))) {
+        throw antwortfehler(ort.name, `Antwort enthaelt keinen USt-Satz (data.${ort.pfad}.vatRate)`);
+    }
+    const raus = {
+        id: kennung(ort, 'id', a.id),
+        name: text(a.name),
+        unitPriceCents: ganzzahlOderNull(ort, 'unitPriceCents', a.unitPriceCents),
+        vatRate: typeof vatRate === 'number' ? vatRate : null,
+        unit: text(a.unit),
+        number: text(a.number),
+        ean: text(a.ean),
+        internalCode: text(a.internalCode),
+        groupId: text(a.groupId),
+        revenueGroupId: text(a.revenueGroupId),
+        stockTracked: a.stockTracked === true,
+        stockLocationIds: standorte,
+        minStock: ganzzahlOderNull(ort, 'minStock', a.minStock),
+        active: a.active !== false,
+        createdAt: text(a.createdAt),
+        updatedAt: text(a.updatedAt),
+    };
+    for (const feld of ['externalIds', 'metadata', 'variantAttributes']) {
+        const abb = textAbbildung(a[feld]);
+        if (abb)
+            raus[feld] = abb;
+    }
+    if (typeof a.variantGroupId === 'string')
+        raus.variantGroupId = a.variantGroupId;
+    // Nur mit dem Recht `costs`; ohne fehlt das Feld ganz.
+    if (hat(a, 'purchasePriceMicros'))
+        raus.purchasePriceMicros = ganzzahlOderNull(ort, 'purchasePriceMicros', a.purchasePriceMicros);
+    return raus;
+}
+// ---- Standorte ------------------------------------------------------------------
+const TYPEN = new Set(LOCATION_TYPES);
+const textOderNull = (w) => (typeof w === 'string' && w !== '' ? w : null);
+export function standort(ort, w) {
+    const s = eintrag(ort, w);
+    const a = objekt(s.address);
+    const teile = a ? { street: textOderNull(a.street), zip: textOderNull(a.zip), city: textOderNull(a.city), country: textOderNull(a.country) } : null;
+    return {
+        id: kennung(ort, 'id', s.id),
+        name: typeof s.name === 'string' ? s.name : '',
+        type: typeof s.type === 'string' && TYPEN.has(s.type) ? s.type : null,
+        // Eine Adresse ohne einen einzigen Teil ist keine Adresse.
+        address: teile && Object.values(teile).some((t) => t !== null) ? teile : null,
+        licensePlate: textOderNull(s.licensePlate),
+        active: s.active !== false,
+        virtual: s.virtual === true,
+    };
+}
+// ---- Bestand ------------------------------------------------------------------
+export function bestand(ort, w) {
+    const b = eintrag(ort, w);
+    return {
+        articleId: kennung(ort, 'articleId', b.articleId),
+        locationId: kennung(ort, 'locationId', b.locationId),
+        onHand: ganzzahl(ort, 'onHand', b.onHand),
+        reserved: ganzzahl(ort, 'reserved', b.reserved),
+        available: ganzzahl(ort, 'available', b.available),
+        defective: ganzzahl(ort, 'defective', b.defective),
+        sequence: ganzzahl(ort, 'sequence', b.sequence),
+        updatedAt: text(b.updatedAt),
+    };
+}
+export function wert(ort, w) {
+    const v = eintrag(ort, w);
+    return {
+        articleId: kennung(ort, 'articleId', v.articleId),
+        stockValueCents: ganzzahl(ort, 'stockValueCents', v.stockValueCents),
+        averageCostMicros: ganzzahlOderNull(ort, 'averageCostMicros', v.averageCostMicros),
+    };
+}
+// ---- Bewegungen ------------------------------------------------------------------
+function los(ort, w) {
+    const l = eintrag(ort, w);
+    const raus = {
+        lotId: text(l.lotId),
+        quantity: ganzzahl(ort, 'quantity', l.quantity),
+        expiresOn: text(l.expiresOn),
+        batch: text(l.batch),
+        serialNumber: text(l.serialNumber),
+        receivedAt: text(l.receivedAt),
+    };
+    if (hat(l, 'valueCents'))
+        raus.valueCents = ganzzahlOderNull(ort, 'valueCents', l.valueCents);
+    return raus;
+}
+export function bewegung(ort, w) {
+    const b = eintrag(ort, w);
+    const nachher = objekt(b.stockAfter);
+    const quelle = objekt(b.source);
+    const lose = b.lots === undefined || b.lots === null ? [] : b.lots;
+    if (!Array.isArray(lose))
+        throw antwortfehler(ort.name, `Antwort ist unbrauchbar (data.${ort.pfad}.lots ist keine Liste)`);
+    const nachherOrt = { name: ort.name, pfad: `${ort.pfad}.stockAfter` };
+    const raus = {
+        id: kennung(ort, 'id', b.id),
+        type: text(b.type),
+        articleId: text(b.articleId),
+        locationId: text(b.locationId),
+        condition: text(b.condition),
+        quantityDelta: ganzzahl(ort, 'quantityDelta', b.quantityDelta),
+        stockAfter: nachher
+            ? { sellable: ganzzahl(nachherOrt, 'sellable', nachher.sellable), defective: ganzzahl(nachherOrt, 'defective', nachher.defective) }
+            : null,
+        operationId: text(b.operationId),
+        source: quelle
+            ? {
+                type: text(quelle.type),
+                id: text(quelle.id),
+                register: text(quelle.register),
+                position: typeof quelle.position === 'number' && Number.isSafeInteger(quelle.position) ? quelle.position : null,
+            }
+            : null,
+        viennaDay: text(b.viennaDay),
+        time: text(b.time),
+        lots: lose.map((l, i) => los({ name: ort.name, pfad: `${ort.pfad}.lots[${i}]` }, l)),
+    };
+    if (hat(b, 'valueDeltaCents'))
+        raus.valueDeltaCents = ganzzahlOderNull(ort, 'valueDeltaCents', b.valueDeltaCents);
+    if (hat(b, 'consumedValueCents'))
+        raus.consumedValueCents = ganzzahlOderNull(ort, 'consumedValueCents', b.consumedValueCents);
+    return raus;
+}
+// ---- Webhooks ------------------------------------------------------------------
+const zahlOderNull = (w) => (typeof w === 'number' && Number.isFinite(w) ? w : null);
+export function webhook(ort, w) {
+    const h = eintrag(ort, w);
+    const z = objekt(h.lastDelivery);
+    return {
+        id: kennung(ort, 'id', h.id),
+        url: typeof h.url === 'string' ? h.url : '',
+        events: Array.isArray(h.events) ? h.events.filter((e) => typeof e === 'string') : [],
+        active: h.active !== false,
+        description: text(h.description),
+        createdAt: text(h.createdAt),
+        lastDelivery: z ? { at: text(z.at), status: text(z.status), statusCode: zahlOderNull(z.statusCode) } : null,
+        consecutiveFailures: typeof h.consecutiveFailures === 'number' && Number.isSafeInteger(h.consecutiveFailures) ? h.consecutiveFailures : 0,
+    };
+}
+export function zustellung(ort, w) {
+    const z = eintrag(ort, w);
+    return {
+        deliveryId: kennung(ort, 'deliveryId', z.deliveryId),
+        webhookId: text(z.webhookId),
+        event: text(z.event),
+        eventId: text(z.eventId),
+        status: text(z.status),
+        attempts: typeof z.attempts === 'number' && Number.isSafeInteger(z.attempts) ? z.attempts : 0,
+        statusCode: zahlOderNull(z.statusCode),
+        response: text(z.response),
+        error: text(z.error),
+        createdAt: text(z.createdAt),
+        lastAttemptAt: text(z.lastAttemptAt),
+        nextAttemptAt: text(z.nextAttemptAt),
+        test: z.test === true,
+    };
+}
+export function probeZustellung(ort, w, webhookId) {
+    const z = eintrag(ort, w);
+    return {
+        deliveryId: kennung(ort, 'deliveryId', z.deliveryId),
+        webhookId: typeof z.webhookId === 'string' && z.webhookId ? z.webhookId : webhookId,
+        status: text(z.status),
+        statusCode: zahlOderNull(z.statusCode),
+    };
+}
+// ---- Ereignisse ------------------------------------------------------------------
+export function bestandGeaendert(ort, w) {
+    const d = eintrag(ort, w);
+    const ursache = d.cause;
+    if (typeof ursache !== 'string' || ursache === '')
+        throw antwortfehler(ort.name, `Ereignis ohne Ursache (${ort.pfad}.cause)`);
+    return { ...bestand(ort, d), cause: ursache, movementId: textOderNull(d.movementId) };
+}
+export function unterMindestbestand(ort, w) {
+    const d = eintrag(ort, w);
+    return {
+        articleId: kennung(ort, 'articleId', d.articleId),
+        locationId: kennung(ort, 'locationId', d.locationId),
+        available: ganzzahl(ort, 'available', d.available),
+        minStock: ganzzahl(ort, 'minStock', d.minStock),
+    };
+}
+// ---- Listen ------------------------------------------------------------------
+/** Eine zugesagte Liste `data.<feld>`, Eintrag fuer Eintrag gelesen. */
+export function liste(name, daten, feld, lesen) {
+    const roh = objekt(daten)?.[feld];
+    if (!Array.isArray(roh)) {
+        const grund = roh === undefined || roh === null
+            ? `Antwort enthaelt keine Liste (data.${feld} fehlt)`
+            : `Antwort ist unbrauchbar (data.${feld} ist keine Liste)`;
+        throw antwortfehler(name, grund);
+    }
+    return roh.map((e, i) => lesen({ name, pfad: `${feld}[${i}]` }, e));
+}
+/** Der Cursor der naechsten Seite; `null` am Ende. Etwas anderes als Text oder `null` ist kaputt. */
+export function naechsterCursor(name, daten) {
+    const c = objekt(daten)?.nextCursor;
+    if (c === undefined || c === null)
+        return null;
+    if (typeof c !== 'string' || c === '')
+        throw antwortfehler(name, 'Antwort ist unbrauchbar (data.nextCursor)');
+    return c;
+}

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

@@ -0,0 +1,319 @@
+/**
+ * Die Modelle der Lager-API, so wie sie am Draht `/v3` stehen.
+ *
+ * **Ganzzahlen mit fester Skala:** Mengen in Tausendstel der Basiseinheit
+ * (`1000` = 1 Stueck, `250` = 0,250 kg), Geld in Cent, Einkaufspreise in
+ * Mikro-Euro (`1_000_000` = 1 €). Nichts davon wird geteilt oder gerundet;
+ * eine Bruchzahl in einer Antwort ist ein Antwortfehler
+ * (`KasseneckValidationError`, `scope: 'response'`), nie ein Ersatzwert.
+ *
+ * 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';
+/**
+ * Ein Artikel, wie `getArticle`, `listArticles`, `lookupArticleByCode` und die
+ * Ereignisse `article.*` ihn senden.
+ *
+ * Optionale Felder fehlen ganz, wenn der Server sie nicht sendet:
+ * `purchasePriceMicros` nur mit dem Recht `costs` (Konto-Schalter
+ * `lagerApi.kosten`, sonst fehlt das Feld, nicht `null`), `externalIds`,
+ * `metadata`, `variantGroupId` und `variantAttributes` nur, wenn der Artikel
+ * sie traegt.
+ */
+export interface Article {
+    id: string;
+    name: string | null;
+    unitPriceCents: number | null;
+    /** USt-Satz in Prozent, z. B. `20`, `10`, `4.9`. */
+    vatRate: number | null;
+    unit: string | null;
+    number: string | null;
+    ean: string | null;
+    internalCode: string | null;
+    groupId: string | null;
+    revenueGroupId: string | null;
+    stockTracked: boolean;
+    /** 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.
+     */
+    minStock: number | null;
+    active: boolean;
+    externalIds?: Record<string, string>;
+    metadata?: Record<string, string>;
+    variantGroupId?: string;
+    variantAttributes?: Record<string, string>;
+    createdAt: string | null;
+    updatedAt: string | null;
+    /**
+     * Einkaufspreis je Basiseinheit in Mikro-Euro (Wiederbeschaffungs- vor
+     * letztem vor Standard-Einkaufspreis); `null` = keiner hinterlegt. Fehlt
+     * ganz ohne das Recht `costs`.
+     */
+    purchasePriceMicros?: number | null;
+}
+export interface ArticleListQuery {
+    /**
+     * Nur Artikel, die seitdem geaendert wurden (inklusive). Die Liste ist nach
+     * `updatedAt` aufsteigend sortiert: wer sich das `updatedAt` des letzten
+     * Treffers merkt und damit wieder fragt, verliert nichts.
+     */
+    updatedSince?: string | Date;
+    groupId?: string;
+    variantGroupId?: string;
+    active?: boolean;
+    stockTracked?: boolean;
+    /** 1–200, Vorgabe des Servers 50. */
+    limit?: number;
+    /** `nextCursor` der vorigen Seite. */
+    cursor?: string;
+}
+export interface ArticlePage {
+    articles: Article[];
+    /** `null` = letzte Seite. */
+    nextCursor: string | null;
+}
+/** Ein Artikel per Code (`number`, `ean`, `internalCode`) oder per eigener Kennung. */
+export type ArticleLookup = string | {
+    code: string;
+} | {
+    externalSystem: string;
+    externalId: string;
+};
+export interface LocationAddress {
+    street: string | null;
+    zip: string | null;
+    city: string | null;
+    country: string | null;
+}
+export interface Location {
+    id: string;
+    name: string;
+    /** `null`: ein Typ, den diese Paketversion nicht kennt. */
+    type: LocationType | null;
+    address: LocationAddress | null;
+    /** Kennzeichen, nur bei `vehicle`. */
+    licensePlate: string | null;
+    /** `false` = aufgeloest. */
+    active: boolean;
+    /** `true` = Hauptstandort, den der Server ohne eigenes Dokument ergaenzt. */
+    virtual: boolean;
+}
+/** Bestand eines Artikels an einem Standort, Mengen in Tausendstel. */
+export interface StockLevel {
+    articleId: string;
+    locationId: string;
+    /** Verkaufbare Menge am Standort. */
+    onHand: number;
+    /** Reserviert (Checkout im Shop). */
+    reserved: number;
+    /** `onHand - reserved`, vom Server gerechnet; darf negativ sein (die Kasse verkauft trotzdem). */
+    available: number;
+    defective: number;
+    /**
+     * Steigt bei jedem Schreiben dieses Bestands um 1. Einen gespeicherten Stand
+     * nur ueberschreiben, wenn `sequence` groesser ist: so richten doppelte oder
+     * verspaetete Ereignisse nichts an.
+     */
+    sequence: number;
+    updatedAt: string | null;
+}
+/** Lagerwert eines Artikels, nur mit dem Recht `costs`. */
+export interface StockValue {
+    articleId: string;
+    stockValueCents: number;
+    /** Durchschnittlicher Einstandspreis je Basiseinheit in Mikro-Euro; `null` bei Menge 0. */
+    averageCostMicros: number | null;
+}
+export interface StockResult {
+    stock: StockLevel[];
+    /** `null` ohne das Recht `costs` (der Server laesst das Feld weg), sonst die Werte. */
+    values: StockValue[] | null;
+}
+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).
+     */
+    belowMinimum?: boolean;
+    /** Nur Zeilen, die sich seitdem geaendert haben (inklusive), nach `updatedAt` aufsteigend. */
+    changedSince?: string | Date;
+    limit?: number;
+    cursor?: string;
+}
+export interface StockPage extends StockResult {
+    nextCursor: string | null;
+}
+export interface StockMovementLot {
+    lotId: string | null;
+    quantity: number;
+    expiresOn: string | null;
+    batch: string | null;
+    serialNumber: string | null;
+    receivedAt: string | null;
+    /** Nur mit dem Recht `costs`. */
+    valueCents?: number | null;
+}
+export interface StockMovementSourceRef {
+    type: StockMovementSource | (string & {}) | null;
+    /** Kennung des Belegs, der Rechnung o. Ae. */
+    id: string | null;
+    /** Kasse, an der verkauft wurde. */
+    register: string | null;
+    /** Position im Beleg bzw. in der Rechnung. */
+    position: number | null;
+}
+/** Eine Zeile des Lagerprotokolls; neueste zuerst. */
+export interface StockMovement {
+    id: string;
+    type: StockMovementType | (string & {}) | null;
+    articleId: string | null;
+    locationId: string | null;
+    condition: StockCondition | (string & {}) | null;
+    /** Mengenaenderung in Tausendstel (Abgang negativ). */
+    quantityDelta: number;
+    /** Bestand am Standort nach der Bewegung. */
+    stockAfter: {
+        sellable: number;
+        defective: number;
+    } | null;
+    operationId: string | null;
+    source: StockMovementSourceRef | null;
+    /** Wiener Tag `YYYY-MM-DD`. */
+    viennaDay: string | null;
+    time: string | null;
+    lots: StockMovementLot[];
+    /** Nur mit dem Recht `costs`. */
+    valueDeltaCents?: number | null;
+    /** Nur mit dem Recht `costs`. */
+    consumedValueCents?: number | null;
+}
+export interface StockMovementQuery {
+    /** Nur nach `articleId` **oder** `locationId` filtern, nicht beides. */
+    articleId?: string;
+    locationId?: string;
+    from?: string | Date;
+    to?: string | Date;
+    type?: StockMovementType;
+    source?: StockMovementSource;
+    limit?: number;
+    cursor?: string;
+}
+export interface StockMovementPage {
+    movements: StockMovement[];
+    nextCursor: string | null;
+}
+export interface InventoryWebhook {
+    id: string;
+    url: string;
+    events: (InventoryWebhookEventType | (string & {}))[];
+    active: boolean;
+    description: string | null;
+    createdAt: string | null;
+    /** Die letzte Zustellung; `null`, solange keine versucht wurde. */
+    lastDelivery: {
+        at: string | null;
+        status: WebhookDeliveryStatus | (string & {}) | null;
+        statusCode: number | null;
+    } | null;
+    /** Fehlversuche in Folge (wie bei Partner-Webhooks); steigt der Wert, stimmt beim Empfaenger etwas nicht. */
+    consecutiveFailures: number;
+}
+export interface CreateInventoryWebhookOptions {
+    /** Vollstaendige `https://`-Adresse, hoechstens 500 Zeichen. */
+    url: string;
+    /** Mindestens eines. */
+    events: (InventoryWebhookEventType | (string & {}))[];
+    /** Hoechstens 120 Zeichen. */
+    description?: string;
+}
+export interface InventoryWebhookPatch {
+    url?: string;
+    events?: (InventoryWebhookEventType | (string & {}))[];
+    active?: boolean;
+    /** `null` loescht die Beschreibung. */
+    description?: string | null;
+}
+export interface InventoryWebhookWithSecret {
+    webhook: InventoryWebhook;
+    /**
+     * Das Secret fuer [verifyInventoryWebhookSignature]. **Es kommt genau einmal**, bei
+     * `createWebhook` bzw. `rotateWebhookSecret`; danach gibt der Server es nie
+     * wieder aus. Nach einem Wechsel gilt sofort nur das neue.
+     */
+    secret: string;
+}
+export interface InventoryWebhookList {
+    webhooks: InventoryWebhook[];
+    /** Die Ereignisse, die dieses Konto abonnieren kann. */
+    events: string[];
+}
+export interface InventoryWebhookTestDelivery {
+    /** Kennung der Zustellung (Kopfzeile `X-Kasseneck-Delivery`), wie bei Partner-Webhooks. */
+    deliveryId: string;
+    webhookId: string;
+    status: WebhookDeliveryStatus | (string & {}) | null;
+    statusCode: number | null;
+}
+export interface InventoryWebhookTestResult {
+    eventId: string;
+    event: string;
+    deliveries: InventoryWebhookTestDelivery[];
+}
+export interface InventoryWebhookDelivery {
+    /** Kennung der Zustellung (Kopfzeile `X-Kasseneck-Delivery`), wie bei Partner-Webhooks. */
+    deliveryId: string;
+    webhookId: string | null;
+    event: string | null;
+    eventId: string | null;
+    /** `dropped`: der Webhook wurde vor der Faelligkeit deaktiviert oder geloescht. */
+    status: WebhookDeliveryStatus | (string & {}) | null;
+    attempts: number;
+    statusCode: number | null;
+    /** Auszug der Antwort des Empfaengers, hoechstens 500 Zeichen. */
+    response: string | null;
+    error: string | null;
+    createdAt: string | null;
+    lastAttemptAt: string | null;
+    nextAttemptAt: string | null;
+    test: boolean;
+}
+/** Nutzlast von `stock.changed`: der aktuelle Stand, nicht die Aenderung. */
+export interface StockChangedEventData extends StockLevel {
+    cause: StockChangeCause | (string & {});
+    /** Die Bewegung, aus der `cause` stammt; `null` bei `other` ohne Bewegung. */
+    movementId: string | null;
+}
+/** Nutzlast von `stock.below_minimum`: nur beim Unterschreiten, nicht bei jedem weiteren Sinken. */
+export interface StockBelowMinimumEventData {
+    articleId: string;
+    locationId: string;
+    available: number;
+    /**
+     * Der Mindestbestand des Standorts in Tausendstel – die unterschrittene Schwelle,
+     * gemessen am Bestand `onHand`. Der `minStock` des Artikels allein loest nie aus.
+     */
+    minStock: number;
+}
+export interface InventoryWebhookEnvelope<T extends InventoryWebhookEventType, D> {
+    /** `evt_…`: darauf entdoppeln. */
+    id: string;
+    type: T;
+    /** Millisekunden seit 1970 (UTC). */
+    createdAt: number;
+    /** Das Konto, dessen Lager das Ereignis betrifft. */
+    accountId: string;
+    /**
+     * `true` nur bei einer Probe aus `sendWebhookTest` (erfundene Nutzlast).
+     * An den Anfang jedes Handlers: `if (event.test) return;`
+     */
+    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>;

package/dist/esm/inventory/typen.js

@@ -0,0 +1,13 @@
+/**
+ * Die Modelle der Lager-API, so wie sie am Draht `/v3` stehen.
+ *
+ * **Ganzzahlen mit fester Skala:** Mengen in Tausendstel der Basiseinheit
+ * (`1000` = 1 Stueck, `250` = 0,250 kg), Geld in Cent, Einkaufspreise in
+ * Mikro-Euro (`1_000_000` = 1 €). Nichts davon wird geteilt oder gerundet;
+ * eine Bruchzahl in einer Antwort ist ein Antwortfehler
+ * (`KasseneckValidationError`, `scope: 'response'`), nie ein Ersatzwert.
+ *
+ * Zeitpunkte sind ISO 8601 in UTC (`2026-10-06T08:15:00.000Z`), Tage (Wiener
+ * Tag) `YYYY-MM-DD`.
+ */
+export {};

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

@@ -0,0 +1,76 @@
+/**
+ * Der Vertrag der Lager-API (Backend Stufe 5a) als Daten: Endpunkte,
+ * Wertkataloge, Ereignisse und Fehlercodes, 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.
+ */
+/** 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"];
+export type InventoryEndpoint = (typeof INVENTORY_ENDPOINTS)[number];
+/** Art eines Standorts (Katalog `STANDORT_TYP`). */
+export declare const LOCATION_TYPES: readonly ["warehouse", "store", "vehicle", "other"];
+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).
+ */
+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 type StockMovementType = (typeof STOCK_MOVEMENT_TYPES)[number];
+/**
+ * Woher eine Bewegung kommt (Katalog `BEWEGUNG_QUELLE`); zugleich der Filter
+ * `source`. `receipt` ist der Kassenbeleg wie ueberall in der API (der
+ * Wareneingang ist die Bewegungsart `goods_receipt`).
+ */
+export declare const STOCK_MOVEMENT_SOURCES: readonly ["receipt", "invoice", "cancellation", "credit_note", "panel", "register", "api", "stocktake", "system"];
+export type StockMovementSource = (typeof STOCK_MOVEMENT_SOURCES)[number];
+/** Zustand der Ware an einer Bewegung (Katalog `LAGER_ZUSTAND`). */
+export declare const STOCK_CONDITIONS: readonly ["sellable", "defective"];
+export type StockCondition = (typeof STOCK_CONDITIONS)[number];
+/**
+ * Ursache eines `stock.changed` (Katalog `LAGER_URSACHE`), abgeleitet aus der
+ * juengsten Bewegung mit Mengenwirkung. `other`: keine Regel passt oder es
+ * gibt keine Bewegung (dann ist `movementId` `null`).
+ */
+export declare const STOCK_CHANGE_CAUSES: readonly ["sale", "invoice", "credit_note", "cancellation", "goods_receipt", "transfer", "loss", "condition", "reversal", "reservation", "stocktake", "takeover", "other"];
+export type StockChangeCause = (typeof STOCK_CHANGE_CAUSES)[number];
+/** Stand einer Zustellung (Katalog `ZUSTELLUNG`, derselbe wie bei Partner-Webhooks). */
+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.*`.
+ */
+export declare const INVENTORY_WEBHOOK_EVENTS: readonly ["stock.changed", "stock.below_minimum", "article.created", "article.updated", "article.deactivated"];
+export type InventoryWebhookEventType = (typeof INVENTORY_WEBHOOK_EVENTS)[number];
+/**
+ * Die Felder der Huelle jeder Zustellung, in der Reihenfolge am Draht. Statt
+ * `partnerId` (Partner-Webhooks) traegt sie `accountId`; `test` steht nur auf
+ * Probesendungen.
+ */
+export declare const INVENTORY_WEBHOOK_ENVELOPE_FIELDS: readonly ["id", "type", "createdAt", "accountId", "test", "data"];
+/** Hoechstzahl der Webhooks je Konto (`webhook_limit`, wie bei Partner-Webhooks). */
+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).
+ */
+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 type InventoryErrorCode = (typeof INVENTORY_ERROR_CODES)[number];
+/**
+ * Codes, die Anmeldung und Rand auf jedem Lager-Aufruf erzeugen koennen,
+ * soweit sie nicht schon in [INVENTORY_ERROR_CODES] stehen: `errorCodes.auth`
+ * ohne die des Partner-Zugangs und `errorCodes.edge` (sortiert), zuletzt
+ * `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 type InventoryRequestErrorCode = (typeof INVENTORY_REQUEST_ERROR_CODES)[number];