@kreiseck/kasseneck-api 1.3.0 → 1.4.0

package/dist/cjs/inventory/endpunkte.js

@@ -0,0 +1,285 @@
+"use strict";
+/**
+ * Die Aufrufe der Lager-API: Artikel, Standorte, Bestand und Bewegungen
+ * lesen, Konto-Webhooks verwalten (Backend Stufe 5a).
+ *
+ * Jede Funktion nimmt den Transport als ersten Parameter und ist einzeln
+ * importierbar; die Fassade [createInventoryClient] bindet ihn nur einmal.
+ *
+ * **Geprueft wird hier nur, was ohne Netz sicher falsch ist** (leere Kennung,
+ * `limit` ausserhalb 1–200, eine Aenderung ohne Feld). Alles Fachliche prueft
+ * der Server und meldet es als `validation` mit `errors[]`; zwei Pruefungen
+ * hiessen zwei Wahrheiten.
+ *
+ * Lesen hat keine Wirkung: nach einem Zeitlimit darf derselbe Aufruf
+ * wiederholt werden. Bei `rate_limited` vorher `retryAfterSec` warten
+ * ([inventoryRetryAfterSec]).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getArticle = getArticle;
+exports.listArticles = listArticles;
+exports.iterateArticles = iterateArticles;
+exports.lookupArticleByCode = lookupArticleByCode;
+exports.listLocations = listLocations;
+exports.getStock = getStock;
+exports.listStock = listStock;
+exports.iterateStock = iterateStock;
+exports.listStockMovements = listStockMovements;
+exports.iterateStockMovements = iterateStockMovements;
+exports.createWebhook = createWebhook;
+exports.updateWebhook = updateWebhook;
+exports.deleteWebhook = deleteWebhook;
+exports.listWebhooks = listWebhooks;
+exports.rotateWebhookSecret = rotateWebhookSecret;
+exports.sendWebhookTest = sendWebhookTest;
+exports.listWebhookDeliveries = listWebhookDeliveries;
+const errors_js_1 = require("../client/errors.js");
+const lesen_js_1 = require("./lesen.js");
+const vertrag_js_1 = require("./vertrag.js");
+function anfragefehler(name, grund) {
+    return new errors_js_1.KasseneckValidationError(name, grund, 'request');
+}
+/** Eine Kennung, die gesendet werden muss: Text mit mindestens einem Zeichen ausser Leerraum. */
+function kennung(name, feld, wert) {
+    if (typeof wert !== 'string' || wert.trim() === '')
+        throw anfragefehler(name, `${feld} fehlt`);
+    return wert;
+}
+/** Felder, die einen Zeitpunkt tragen: ein `Date` geht als ISO 8601 UTC hinaus. */
+const ZEITFELDER = new Set(['updatedSince', 'changedSince', 'from', 'to']);
+/**
+ * Die Abfrage einer Liste als Parameter. Unbekannte Felder gehen unveraendert
+ * hinaus (der Server weist sie mit `validation` ab), `undefined` faellt weg.
+ */
+function abfrage(name, query) {
+    if (query === undefined || query === null)
+        return {};
+    if (typeof query !== 'object' || Array.isArray(query))
+        throw anfragefehler(name, 'Abfrage muss ein Objekt sein');
+    const raus = {};
+    for (const [feld, w] of Object.entries(query)) {
+        if (w === undefined)
+            continue;
+        if (ZEITFELDER.has(feld) && w instanceof Date) {
+            if (Number.isNaN(w.getTime()))
+                throw anfragefehler(name, `${feld} ist kein gueltiger Zeitpunkt`);
+            raus[feld] = w.toISOString();
+            continue;
+        }
+        raus[feld] = w;
+    }
+    if (raus.limit !== undefined) {
+        const limit = raus.limit;
+        if (typeof limit !== 'number' || !Number.isInteger(limit) || limit < 1 || limit > vertrag_js_1.INVENTORY_LIST_LIMIT_MAX) {
+            throw anfragefehler(name, `limit muss eine ganze Zahl von 1 bis ${vertrag_js_1.INVENTORY_LIST_LIMIT_MAX} sein`);
+        }
+    }
+    if (raus.cursor !== undefined)
+        kennung(name, 'cursor', raus.cursor);
+    return raus;
+}
+/**
+ * Blaettert ueber alle Seiten, Eintrag fuer Eintrag. Derselbe Cursor zweimal
+ * waere eine Endlosschleife: dann endet die Schleife mit einem Antwortfehler.
+ */
+async function* seitenweise(name, start, seite) {
+    const gesehen = new Set();
+    // Auch der Startcursor zaehlt: nennt die erste Antwort ihn wieder, waere es dieselbe Seite.
+    if (start)
+        gesehen.add(start);
+    let cursor = start;
+    for (;;) {
+        const { eintraege, nextCursor } = await seite(cursor);
+        yield* eintraege;
+        if (nextCursor === null)
+            return;
+        if (gesehen.has(nextCursor))
+            throw (0, lesen_js_1.antwortfehler)(name, 'Antwort nennt denselben nextCursor zweimal');
+        gesehen.add(nextCursor);
+        cursor = nextCursor;
+    }
+}
+// ---- Artikel ------------------------------------------------------------------
+async function getArticle(transport, articleId) {
+    const name = 'getArticle';
+    const daten = await transport(name, { articleId: kennung(name, 'articleId', articleId) });
+    return (0, lesen_js_1.artikel)({ name, pfad: 'article' }, (0, lesen_js_1.objekt)(daten)?.article);
+}
+async function listArticles(transport, query) {
+    const name = 'listArticles';
+    const daten = await transport(name, abfrage(name, query));
+    return { articles: (0, lesen_js_1.liste)(name, daten, 'articles', lesen_js_1.artikel), nextCursor: (0, lesen_js_1.naechsterCursor)(name, daten) };
+}
+/** Alle Artikel der Abfrage, Seite fuer Seite ueber `nextCursor`. */
+function iterateArticles(transport, query) {
+    const { cursor, ...rest } = query ?? {};
+    return seitenweise('listArticles', cursor, async (c) => {
+        const s = await listArticles(transport, { ...rest, cursor: c });
+        return { eintraege: s.articles, nextCursor: s.nextCursor };
+    });
+}
+/**
+ * Ein aktiver Artikel per Code (`number`, `ean` oder `internalCode`) oder per
+ * eigener Kennung aus `externalIds` (`{ externalSystem: 'shop', externalId: '4711' }`).
+ * Ein stillgelegter Artikel gilt als nicht gefunden (`article_not_found`).
+ */
+async function lookupArticleByCode(transport, lookup) {
+    const name = 'lookupArticleByCode';
+    let params;
+    if (typeof lookup === 'string') {
+        params = { code: kennung(name, 'code', lookup) };
+    }
+    else if (lookup !== null && typeof lookup === 'object' && !Array.isArray(lookup)) {
+        const l = lookup;
+        const extern = l.externalSystem !== undefined || l.externalId !== undefined;
+        if (l.code !== undefined && extern)
+            throw anfragefehler(name, 'entweder code oder externalSystem mit externalId');
+        params = extern
+            ? { externalSystem: kennung(name, 'externalSystem', l.externalSystem), externalId: kennung(name, 'externalId', l.externalId) }
+            : { code: kennung(name, 'code', l.code) };
+    }
+    else {
+        throw anfragefehler(name, 'Code als Text oder { code } bzw. { externalSystem, externalId } erwartet');
+    }
+    const daten = await transport(name, params);
+    return (0, lesen_js_1.artikel)({ name, pfad: 'article' }, (0, lesen_js_1.objekt)(daten)?.article);
+}
+// ---- Standorte und Bestand -----------------------------------------------------------
+/** Alle Standorte des Kontos, samt aufgeloesten (`active: false`) und dem Hauptstandort. */
+async function listLocations(transport) {
+    const name = 'listLocations';
+    return (0, lesen_js_1.liste)(name, await transport(name, {}), 'locations', lesen_js_1.standort);
+}
+/** Die Werte (`values`): fehlt das Feld, fehlt das Recht `costs` -> `null`, nie `[]`. */
+function werte(name, daten) {
+    const roh = (0, lesen_js_1.objekt)(daten)?.values;
+    if (roh === undefined || roh === null)
+        return null;
+    return (0, lesen_js_1.liste)(name, daten, 'values', lesen_js_1.wert);
+}
+/** Bestand eines Artikels je Standort. */
+async function getStock(transport, articleId) {
+    const name = 'getStock';
+    const daten = await transport(name, { articleId: kennung(name, 'articleId', articleId) });
+    return { stock: (0, lesen_js_1.liste)(name, daten, 'stock', lesen_js_1.bestand), values: werte(name, daten) };
+}
+async function listStock(transport, query) {
+    const name = 'listStock';
+    const daten = await transport(name, abfrage(name, query));
+    return { stock: (0, lesen_js_1.liste)(name, daten, 'stock', lesen_js_1.bestand), values: werte(name, daten), nextCursor: (0, lesen_js_1.naechsterCursor)(name, daten) };
+}
+/**
+ * Alle Bestandszeilen der Abfrage, Seite fuer Seite. Die Werte (`values`)
+ * stehen je Seite in [listStock]; der Iterator liefert nur die Zeilen.
+ */
+function iterateStock(transport, query) {
+    const { cursor, ...rest } = query ?? {};
+    return seitenweise('listStock', cursor, async (c) => {
+        const s = await listStock(transport, { ...rest, cursor: c });
+        return { eintraege: s.stock, nextCursor: s.nextCursor };
+    });
+}
+/** Das Lagerprotokoll, neueste zuerst. */
+async function listStockMovements(transport, query) {
+    const name = 'listStockMovements';
+    const daten = await transport(name, abfrage(name, query));
+    return { movements: (0, lesen_js_1.liste)(name, daten, 'movements', lesen_js_1.bewegung), nextCursor: (0, lesen_js_1.naechsterCursor)(name, daten) };
+}
+function iterateStockMovements(transport, query) {
+    const { cursor, ...rest } = query ?? {};
+    return seitenweise('listStockMovements', cursor, async (c) => {
+        const s = await listStockMovements(transport, { ...rest, cursor: c });
+        return { eintraege: s.movements, nextCursor: s.nextCursor };
+    });
+}
+// ---- Webhooks ------------------------------------------------------------------
+function mitSecret(name, daten) {
+    const o = (0, lesen_js_1.objekt)(daten);
+    const secret = o?.secret;
+    if (typeof secret !== 'string' || secret === '') {
+        throw (0, lesen_js_1.antwortfehler)(name, 'Antwort enthaelt kein secret; ohne es laesst sich keine Zustellung pruefen');
+    }
+    return { webhook: (0, lesen_js_1.webhook)({ name, pfad: 'webhook' }, o?.webhook), secret };
+}
+/**
+ * Legt einen Webhook an (hoechstens 5 je Konto, `webhook_limit`).
+ * **Das Secret in der Antwort kommt nur dieses eine Mal**; sofort dorthin
+ * schreiben, wo der Empfaenger es liest, nicht in ein Protokoll.
+ */
+async function createWebhook(transport, options) {
+    const name = 'createWebhook';
+    const url = kennung(name, 'url', options?.url);
+    if (!Array.isArray(options.events) || options.events.length === 0) {
+        throw anfragefehler(name, 'events ist leer; ein Webhook ohne Ereignis bekaeme nie etwas');
+    }
+    const params = { url, events: options.events };
+    if (options.description !== undefined)
+        params.description = options.description;
+    return mitSecret(name, await transport(name, params));
+}
+/** Aendert nur die genannten Felder; `description: null` loescht die Beschreibung. */
+async function updateWebhook(transport, webhookId, patch) {
+    const name = 'updateWebhook';
+    const id = kennung(name, 'webhookId', webhookId);
+    if (patch === null || typeof patch !== 'object' || Array.isArray(patch))
+        throw anfragefehler(name, 'patch muss ein Objekt sein');
+    const params = { webhookId: id };
+    for (const [feld, w] of Object.entries(patch))
+        if (w !== undefined)
+            params[feld] = w;
+    if (Object.keys(params).length === 1)
+        throw anfragefehler(name, 'patch nennt keine Aenderung');
+    const daten = await transport(name, params);
+    return (0, lesen_js_1.webhook)({ name, pfad: 'webhook' }, (0, lesen_js_1.objekt)(daten)?.webhook);
+}
+async function deleteWebhook(transport, webhookId) {
+    const name = 'deleteWebhook';
+    const id = kennung(name, 'webhookId', webhookId);
+    const o = (0, lesen_js_1.objekt)(await transport(name, { webhookId: id }));
+    return { webhookId: typeof o?.webhookId === 'string' && o.webhookId ? o.webhookId : id, deleted: o?.deleted === true };
+}
+/** Die Webhooks des Kontos und die Ereignisse, die es abonnieren kann. */
+async function listWebhooks(transport) {
+    const name = 'listWebhooks';
+    const daten = await transport(name, {});
+    const ereignisse = (0, lesen_js_1.objekt)(daten)?.events;
+    return {
+        webhooks: (0, lesen_js_1.liste)(name, daten, 'webhooks', lesen_js_1.webhook),
+        events: Array.isArray(ereignisse) ? ereignisse.filter((e) => typeof e === 'string') : [],
+    };
+}
+/**
+ * Ein neues Secret fuer denselben Webhook. Ab der Antwort gilt nur noch das
+ * neue (keine Uebergangsfrist): erst speichern, dann weiterarbeiten.
+ */
+async function rotateWebhookSecret(transport, webhookId) {
+    const name = 'rotateWebhookSecret';
+    return mitSecret(name, await transport(name, { webhookId: kennung(name, 'webhookId', webhookId) }));
+}
+/**
+ * Eine Probe genau dieses Ereignisses an genau diesen Webhook, mit erfundener
+ * Nutzlast und `test: true` in der Huelle. Der Webhook muss das Ereignis
+ * abonnieren (`event_not_subscribed`) und aktiv sein (`webhook_inactive`).
+ */
+async function sendWebhookTest(transport, webhookId, event) {
+    const name = 'sendWebhookTest';
+    const id = kennung(name, 'webhookId', webhookId);
+    const ereignis = kennung(name, 'event', event);
+    const daten = await transport(name, { webhookId: id, event: ereignis });
+    const o = (0, lesen_js_1.objekt)(daten);
+    return {
+        eventId: typeof o?.eventId === 'string' ? o.eventId : '',
+        event: typeof o?.event === 'string' ? o.event : ereignis,
+        deliveries: (0, lesen_js_1.liste)(name, daten, 'deliveries', (ort, e) => (0, lesen_js_1.probeZustellung)(ort, e, id)),
+    };
+}
+/** Die letzten Zustellungen, neueste zuerst; mit `webhookId` nur die eines Webhooks. */
+async function listWebhookDeliveries(transport, options = {}) {
+    const name = 'listWebhookDeliveries';
+    const params = {};
+    if (options.webhookId !== undefined)
+        params.webhookId = kennung(name, 'webhookId', options.webhookId);
+    if (options.limit !== undefined)
+        Object.assign(params, abfrage(name, { limit: options.limit }));
+    return (0, lesen_js_1.liste)(name, await transport(name, params), 'deliveries', lesen_js_1.zustellung);
+}

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

@@ -0,0 +1,33 @@
+/**
+ * Fehler der Lager-API auswerten: am Code, nie am Text.
+ *
+ * Es zaehlen die Codes der Lager-Endpunkte ([INVENTORY_ERROR_CODES]) und die,
+ * die Anmeldung und Rand auf jedem Aufruf erzeugen koennen
+ * ([INVENTORY_REQUEST_ERROR_CODES]). Ein fremder Code ist fuer diese Helfer
+ * kein Lager-Fehler: wer darauf verzweigt, tut es bewusst ueber
+ * `KasseneckApiError.code`.
+ */
+import type { KasseneckApiError } from '../client/errors.js';
+import { type InventoryErrorCode, type InventoryRequestErrorCode } from './vertrag.js';
+/** Ein Code, den ein Lager-Aufruf liefern kann. */
+export type InventoryApiErrorCode = InventoryErrorCode | InventoryRequestErrorCode;
+export declare function isInventoryErrorCode(value: unknown): value is InventoryApiErrorCode;
+/** Der Fehlercode eines geworfenen Fehlers; `undefined`, wenn es keiner der Lager-API ist. */
+export declare function inventoryErrorCode(error: unknown): InventoryApiErrorCode | undefined;
+/** Kurzform fuer `catch (e) { if (isInventoryError(e, 'article_not_found')) … }`. */
+export declare function isInventoryError(error: unknown, code?: InventoryApiErrorCode): error is KasseneckApiError;
+/** Ein Feldfehler aus `data.errors[]` einer `validation`-Antwort. */
+export interface InventoryFieldError {
+    /** Feld der gesendeten Anfrage, z. B. `limit` oder `events`. */
+    field: string;
+    message: string;
+}
+/** Die Feldfehler einer `validation`-Antwort; leer, wenn es keine sind. */
+export declare function inventoryFieldErrors(error: unknown): InventoryFieldError[];
+/**
+ * Wie lange `rate_limited` noch gilt, in Sekunden (`data.retryAfterSec`,
+ * dasselbe wie die Kopfzeile `Retry-After`). `undefined`, wenn der Fehler kein
+ * `rate_limited` ist oder der Server keine Angabe macht. Die Grenze gilt je
+ * Konto (etwa 20 Anfragen je Sekunde, kurze Spitzen bis 40).
+ */
+export declare function inventoryRetryAfterSec(error: unknown): number | undefined;

package/dist/cjs/inventory/fehler.js

@@ -0,0 +1,47 @@
+"use strict";
+/**
+ * Fehler der Lager-API auswerten: am Code, nie am Text.
+ *
+ * Es zaehlen die Codes der Lager-Endpunkte ([INVENTORY_ERROR_CODES]) und die,
+ * die Anmeldung und Rand auf jedem Aufruf erzeugen koennen
+ * ([INVENTORY_REQUEST_ERROR_CODES]). Ein fremder Code ist fuer diese Helfer
+ * kein Lager-Fehler: wer darauf verzweigt, tut es bewusst ueber
+ * `KasseneckApiError.code`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInventoryErrorCode = isInventoryErrorCode;
+exports.inventoryErrorCode = inventoryErrorCode;
+exports.isInventoryError = isInventoryError;
+exports.inventoryFieldErrors = inventoryFieldErrors;
+exports.inventoryRetryAfterSec = inventoryRetryAfterSec;
+const fehlercodes_js_1 = require("../client/fehlercodes.js");
+const vertrag_js_1 = require("./vertrag.js");
+const BEKANNT = new Set([...vertrag_js_1.INVENTORY_ERROR_CODES, ...vertrag_js_1.INVENTORY_REQUEST_ERROR_CODES]);
+function isInventoryErrorCode(value) {
+    return typeof value === 'string' && BEKANNT.has(value);
+}
+/** Der Fehlercode eines geworfenen Fehlers; `undefined`, wenn es keiner der Lager-API ist. */
+function inventoryErrorCode(error) {
+    return (0, fehlercodes_js_1.bekannterCode)(error, BEKANNT);
+}
+/** Kurzform fuer `catch (e) { if (isInventoryError(e, 'article_not_found')) … }`. */
+function isInventoryError(error, code) {
+    const gefunden = inventoryErrorCode(error);
+    return gefunden !== undefined && (code === undefined || gefunden === code);
+}
+/** Die Feldfehler einer `validation`-Antwort; leer, wenn es keine sind. */
+function inventoryFieldErrors(error) {
+    return (0, fehlercodes_js_1.feldfehlerVon)(error);
+}
+/**
+ * Wie lange `rate_limited` noch gilt, in Sekunden (`data.retryAfterSec`,
+ * dasselbe wie die Kopfzeile `Retry-After`). `undefined`, wenn der Fehler kein
+ * `rate_limited` ist oder der Server keine Angabe macht. Die Grenze gilt je
+ * Konto (etwa 20 Anfragen je Sekunde, kurze Spitzen bis 40).
+ */
+function inventoryRetryAfterSec(error) {
+    if (inventoryErrorCode(error) !== 'rate_limited')
+        return undefined;
+    const wert = error.details['retryAfterSec'];
+    return typeof wert === 'number' && Number.isFinite(wert) && wert >= 0 ? wert : undefined;
+}

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

@@ -0,0 +1,19 @@
+/**
+ * `@kreiseck/kasseneck-api/inventory` – die Lager-API: Artikel, Standorte,
+ * Bestand und Lagerprotokoll lesen, Konto-Webhooks verwalten und eingehende
+ * Zustellungen pruefen (Backend Stufe 5a).
+ *
+ * Ein eigener Unterpfad wie `invoice`: der `api_key` eines Kontos gehoert auf
+ * einen **Server** (etwa das Backend eines Online-Shops) und soll nicht
+ * versehentlich in ein Browser-Buendel wandern.
+ *
+ * Mengen in Tausendstel der Basiseinheit, Geld in Cent, Einkaufspreise in
+ * Mikro-Euro; alles Ganzzahlen.
+ */
+export { createInventoryClient, type InventoryClient, type InventoryClientOptions } from './api.js';
+export { inventoryKeyAuth, type InventoryKeyAuthOptions } from './auth.js';
+export { isInventoryError, isInventoryErrorCode, inventoryErrorCode, inventoryFieldErrors, inventoryRetryAfterSec, type InventoryApiErrorCode, type InventoryFieldError, } from './fehler.js';
+export { createWebhook, deleteWebhook, getArticle, getStock, iterateArticles, iterateStock, iterateStockMovements, listArticles, listLocations, listStock, listStockMovements, listWebhookDeliveries, listWebhooks, lookupArticleByCode, rotateWebhookSecret, sendWebhookTest, updateWebhook, } from './endpunkte.js';
+export { verifyInventoryWebhookSignature, parseInventoryWebhookEvent, WEBHOOK_SIGNATURE_HEADER, WEBHOOK_EVENT_HEADER, WEBHOOK_DELIVERY_HEADER, WEBHOOK_TOLERANCE_SEC, type VerifyInventoryWebhookOptions, } from './webhook.js';
+export type { Article, ArticleListQuery, ArticleLookup, ArticlePage, CreateInventoryWebhookOptions, InventoryWebhook, InventoryWebhookDelivery, InventoryWebhookEnvelope, InventoryWebhookEvent, InventoryWebhookList, InventoryWebhookPatch, InventoryWebhookTestDelivery, InventoryWebhookTestResult, InventoryWebhookWithSecret, Location, LocationAddress, StockBelowMinimumEventData, StockChangedEventData, StockLevel, StockListQuery, StockMovement, StockMovementLot, StockMovementPage, StockMovementQuery, StockMovementSourceRef, StockPage, StockResult, StockValue, } from './typen.js';
+export { INVENTORY_ENDPOINTS, INVENTORY_ERROR_CODES, INVENTORY_REQUEST_ERROR_CODES, INVENTORY_WEBHOOK_EVENTS, INVENTORY_WEBHOOK_ENVELOPE_FIELDS, INVENTORY_WEBHOOK_LIMIT, INVENTORY_LIST_LIMIT_MAX, LOCATION_TYPES, STOCK_MOVEMENT_TYPES, STOCK_MOVEMENT_SOURCES, STOCK_CONDITIONS, STOCK_CHANGE_CAUSES, WEBHOOK_DELIVERY_STATUSES, type InventoryEndpoint, type InventoryErrorCode, type InventoryRequestErrorCode, type InventoryWebhookEventType, type LocationType, type StockMovementType, type StockMovementSource, type StockCondition, type StockChangeCause, type WebhookDeliveryStatus, } from './vertrag.js';

package/dist/cjs/inventory/index.js

@@ -0,0 +1,64 @@
+"use strict";
+/**
+ * `@kreiseck/kasseneck-api/inventory` – die Lager-API: Artikel, Standorte,
+ * Bestand und Lagerprotokoll lesen, Konto-Webhooks verwalten und eingehende
+ * Zustellungen pruefen (Backend Stufe 5a).
+ *
+ * Ein eigener Unterpfad wie `invoice`: der `api_key` eines Kontos gehoert auf
+ * einen **Server** (etwa das Backend eines Online-Shops) und soll nicht
+ * versehentlich in ein Browser-Buendel wandern.
+ *
+ * Mengen in Tausendstel der Basiseinheit, Geld in Cent, Einkaufspreise in
+ * Mikro-Euro; alles Ganzzahlen.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WEBHOOK_DELIVERY_STATUSES = exports.STOCK_CHANGE_CAUSES = exports.STOCK_CONDITIONS = exports.STOCK_MOVEMENT_SOURCES = exports.STOCK_MOVEMENT_TYPES = exports.LOCATION_TYPES = exports.INVENTORY_LIST_LIMIT_MAX = exports.INVENTORY_WEBHOOK_LIMIT = exports.INVENTORY_WEBHOOK_ENVELOPE_FIELDS = exports.INVENTORY_WEBHOOK_EVENTS = exports.INVENTORY_REQUEST_ERROR_CODES = exports.INVENTORY_ERROR_CODES = exports.INVENTORY_ENDPOINTS = exports.WEBHOOK_TOLERANCE_SEC = exports.WEBHOOK_DELIVERY_HEADER = exports.WEBHOOK_EVENT_HEADER = exports.WEBHOOK_SIGNATURE_HEADER = exports.parseInventoryWebhookEvent = exports.verifyInventoryWebhookSignature = exports.updateWebhook = exports.sendWebhookTest = exports.rotateWebhookSecret = exports.lookupArticleByCode = exports.listWebhooks = exports.listWebhookDeliveries = exports.listStockMovements = exports.listStock = exports.listLocations = exports.listArticles = exports.iterateStockMovements = exports.iterateStock = exports.iterateArticles = exports.getStock = exports.getArticle = exports.deleteWebhook = exports.createWebhook = exports.inventoryRetryAfterSec = exports.inventoryFieldErrors = exports.inventoryErrorCode = exports.isInventoryErrorCode = exports.isInventoryError = exports.inventoryKeyAuth = exports.createInventoryClient = void 0;
+var api_js_1 = require("./api.js");
+Object.defineProperty(exports, "createInventoryClient", { enumerable: true, get: function () { return api_js_1.createInventoryClient; } });
+var auth_js_1 = require("./auth.js");
+Object.defineProperty(exports, "inventoryKeyAuth", { enumerable: true, get: function () { return auth_js_1.inventoryKeyAuth; } });
+var fehler_js_1 = require("./fehler.js");
+Object.defineProperty(exports, "isInventoryError", { enumerable: true, get: function () { return fehler_js_1.isInventoryError; } });
+Object.defineProperty(exports, "isInventoryErrorCode", { enumerable: true, get: function () { return fehler_js_1.isInventoryErrorCode; } });
+Object.defineProperty(exports, "inventoryErrorCode", { enumerable: true, get: function () { return fehler_js_1.inventoryErrorCode; } });
+Object.defineProperty(exports, "inventoryFieldErrors", { enumerable: true, get: function () { return fehler_js_1.inventoryFieldErrors; } });
+Object.defineProperty(exports, "inventoryRetryAfterSec", { enumerable: true, get: function () { return fehler_js_1.inventoryRetryAfterSec; } });
+var endpunkte_js_1 = require("./endpunkte.js");
+Object.defineProperty(exports, "createWebhook", { enumerable: true, get: function () { return endpunkte_js_1.createWebhook; } });
+Object.defineProperty(exports, "deleteWebhook", { enumerable: true, get: function () { return endpunkte_js_1.deleteWebhook; } });
+Object.defineProperty(exports, "getArticle", { enumerable: true, get: function () { return endpunkte_js_1.getArticle; } });
+Object.defineProperty(exports, "getStock", { enumerable: true, get: function () { return endpunkte_js_1.getStock; } });
+Object.defineProperty(exports, "iterateArticles", { enumerable: true, get: function () { return endpunkte_js_1.iterateArticles; } });
+Object.defineProperty(exports, "iterateStock", { enumerable: true, get: function () { return endpunkte_js_1.iterateStock; } });
+Object.defineProperty(exports, "iterateStockMovements", { enumerable: true, get: function () { return endpunkte_js_1.iterateStockMovements; } });
+Object.defineProperty(exports, "listArticles", { enumerable: true, get: function () { return endpunkte_js_1.listArticles; } });
+Object.defineProperty(exports, "listLocations", { enumerable: true, get: function () { return endpunkte_js_1.listLocations; } });
+Object.defineProperty(exports, "listStock", { enumerable: true, get: function () { return endpunkte_js_1.listStock; } });
+Object.defineProperty(exports, "listStockMovements", { enumerable: true, get: function () { return endpunkte_js_1.listStockMovements; } });
+Object.defineProperty(exports, "listWebhookDeliveries", { enumerable: true, get: function () { return endpunkte_js_1.listWebhookDeliveries; } });
+Object.defineProperty(exports, "listWebhooks", { enumerable: true, get: function () { return endpunkte_js_1.listWebhooks; } });
+Object.defineProperty(exports, "lookupArticleByCode", { enumerable: true, get: function () { return endpunkte_js_1.lookupArticleByCode; } });
+Object.defineProperty(exports, "rotateWebhookSecret", { enumerable: true, get: function () { return endpunkte_js_1.rotateWebhookSecret; } });
+Object.defineProperty(exports, "sendWebhookTest", { enumerable: true, get: function () { return endpunkte_js_1.sendWebhookTest; } });
+Object.defineProperty(exports, "updateWebhook", { enumerable: true, get: function () { return endpunkte_js_1.updateWebhook; } });
+var webhook_js_1 = require("./webhook.js");
+Object.defineProperty(exports, "verifyInventoryWebhookSignature", { enumerable: true, get: function () { return webhook_js_1.verifyInventoryWebhookSignature; } });
+Object.defineProperty(exports, "parseInventoryWebhookEvent", { enumerable: true, get: function () { return webhook_js_1.parseInventoryWebhookEvent; } });
+Object.defineProperty(exports, "WEBHOOK_SIGNATURE_HEADER", { enumerable: true, get: function () { return webhook_js_1.WEBHOOK_SIGNATURE_HEADER; } });
+Object.defineProperty(exports, "WEBHOOK_EVENT_HEADER", { enumerable: true, get: function () { return webhook_js_1.WEBHOOK_EVENT_HEADER; } });
+Object.defineProperty(exports, "WEBHOOK_DELIVERY_HEADER", { enumerable: true, get: function () { return webhook_js_1.WEBHOOK_DELIVERY_HEADER; } });
+Object.defineProperty(exports, "WEBHOOK_TOLERANCE_SEC", { enumerable: true, get: function () { return webhook_js_1.WEBHOOK_TOLERANCE_SEC; } });
+var vertrag_js_1 = require("./vertrag.js");
+Object.defineProperty(exports, "INVENTORY_ENDPOINTS", { enumerable: true, get: function () { return vertrag_js_1.INVENTORY_ENDPOINTS; } });
+Object.defineProperty(exports, "INVENTORY_ERROR_CODES", { enumerable: true, get: function () { return vertrag_js_1.INVENTORY_ERROR_CODES; } });
+Object.defineProperty(exports, "INVENTORY_REQUEST_ERROR_CODES", { enumerable: true, get: function () { return vertrag_js_1.INVENTORY_REQUEST_ERROR_CODES; } });
+Object.defineProperty(exports, "INVENTORY_WEBHOOK_EVENTS", { enumerable: true, get: function () { return vertrag_js_1.INVENTORY_WEBHOOK_EVENTS; } });
+Object.defineProperty(exports, "INVENTORY_WEBHOOK_ENVELOPE_FIELDS", { enumerable: true, get: function () { return vertrag_js_1.INVENTORY_WEBHOOK_ENVELOPE_FIELDS; } });
+Object.defineProperty(exports, "INVENTORY_WEBHOOK_LIMIT", { enumerable: true, get: function () { return vertrag_js_1.INVENTORY_WEBHOOK_LIMIT; } });
+Object.defineProperty(exports, "INVENTORY_LIST_LIMIT_MAX", { enumerable: true, get: function () { return vertrag_js_1.INVENTORY_LIST_LIMIT_MAX; } });
+Object.defineProperty(exports, "LOCATION_TYPES", { enumerable: true, get: function () { return vertrag_js_1.LOCATION_TYPES; } });
+Object.defineProperty(exports, "STOCK_MOVEMENT_TYPES", { enumerable: true, get: function () { return vertrag_js_1.STOCK_MOVEMENT_TYPES; } });
+Object.defineProperty(exports, "STOCK_MOVEMENT_SOURCES", { enumerable: true, get: function () { return vertrag_js_1.STOCK_MOVEMENT_SOURCES; } });
+Object.defineProperty(exports, "STOCK_CONDITIONS", { enumerable: true, get: function () { return vertrag_js_1.STOCK_CONDITIONS; } });
+Object.defineProperty(exports, "STOCK_CHANGE_CAUSES", { enumerable: true, get: function () { return vertrag_js_1.STOCK_CHANGE_CAUSES; } });
+Object.defineProperty(exports, "WEBHOOK_DELIVERY_STATUSES", { enumerable: true, get: function () { return vertrag_js_1.WEBHOOK_DELIVERY_STATUSES; } });

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

@@ -0,0 +1,38 @@
+/**
+ * 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 type { Article, InventoryWebhook, InventoryWebhookDelivery, InventoryWebhookTestDelivery, Location, StockBelowMinimumEventData, StockChangedEventData, StockLevel, StockMovement, StockValue } from './typen.js';
+type Roh = Record<string, unknown>;
+/** Ein Leser bekommt den Vorgang (fuer die Meldung) und den Pfad im Rumpf. */
+export interface Ort {
+    name: string;
+    pfad: string;
+}
+export declare function antwortfehler(name: string, grund: string): KasseneckValidationError;
+export declare function objekt(w: unknown): Roh | null;
+export declare function artikel(ort: Ort, w: unknown): Article;
+export declare function standort(ort: Ort, w: unknown): Location;
+export declare function bestand(ort: Ort, w: unknown): StockLevel;
+export declare function wert(ort: Ort, w: unknown): StockValue;
+export declare function bewegung(ort: Ort, w: unknown): StockMovement;
+export declare function webhook(ort: Ort, w: unknown): InventoryWebhook;
+export declare function zustellung(ort: Ort, w: unknown): InventoryWebhookDelivery;
+export declare function probeZustellung(ort: Ort, w: unknown, webhookId: string): InventoryWebhookTestDelivery;
+export declare function bestandGeaendert(ort: Ort, w: unknown): StockChangedEventData;
+export declare function unterMindestbestand(ort: Ort, w: unknown): StockBelowMinimumEventData;
+/** Eine zugesagte Liste `data.<feld>`, Eintrag fuer Eintrag gelesen. */
+export declare function liste<T>(name: string, daten: unknown, feld: string, lesen: (ort: Ort, e: unknown) => T): T[];
+/** Der Cursor der naechsten Seite; `null` am Ende. Etwas anderes als Text oder `null` ist kaputt. */
+export declare function naechsterCursor(name: string, daten: unknown): string | null;
+export {};