@kreiseck/kasseneck-api 1.3.0 → 1.4.0

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

@@ -0,0 +1,71 @@
+/**
+ * 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]).
+ */
+import type { InternerTransport } from '../client/aufrufe.js';
+import type { Article, ArticleListQuery, ArticleLookup, ArticlePage, CreateInventoryWebhookOptions, InventoryWebhook, InventoryWebhookDelivery, InventoryWebhookList, InventoryWebhookPatch, InventoryWebhookTestResult, InventoryWebhookWithSecret, Location, StockLevel, StockListQuery, StockMovement, StockMovementPage, StockMovementQuery, StockPage, StockResult } from './typen.js';
+export declare function getArticle(transport: InternerTransport, articleId: string): Promise<Article>;
+export declare function listArticles(transport: InternerTransport, query?: ArticleListQuery): Promise<ArticlePage>;
+/** Alle Artikel der Abfrage, Seite fuer Seite ueber `nextCursor`. */
+export declare function iterateArticles(transport: InternerTransport, query?: ArticleListQuery): AsyncGenerator<Article, void, undefined>;
+/**
+ * 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`).
+ */
+export declare function lookupArticleByCode(transport: InternerTransport, lookup: ArticleLookup): Promise<Article>;
+/** Alle Standorte des Kontos, samt aufgeloesten (`active: false`) und dem Hauptstandort. */
+export declare function listLocations(transport: InternerTransport): Promise<Location[]>;
+/** Bestand eines Artikels je Standort. */
+export declare function getStock(transport: InternerTransport, articleId: string): Promise<StockResult>;
+export declare function listStock(transport: InternerTransport, query?: StockListQuery): Promise<StockPage>;
+/**
+ * Alle Bestandszeilen der Abfrage, Seite fuer Seite. Die Werte (`values`)
+ * stehen je Seite in [listStock]; der Iterator liefert nur die Zeilen.
+ */
+export declare function iterateStock(transport: InternerTransport, query?: StockListQuery): AsyncGenerator<StockLevel, void, undefined>;
+/** Das Lagerprotokoll, neueste zuerst. */
+export declare function listStockMovements(transport: InternerTransport, query?: StockMovementQuery): Promise<StockMovementPage>;
+export declare function iterateStockMovements(transport: InternerTransport, query?: StockMovementQuery): AsyncGenerator<StockMovement, void, undefined>;
+/**
+ * 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.
+ */
+export declare function createWebhook(transport: InternerTransport, options: CreateInventoryWebhookOptions): Promise<InventoryWebhookWithSecret>;
+/** Aendert nur die genannten Felder; `description: null` loescht die Beschreibung. */
+export declare function updateWebhook(transport: InternerTransport, webhookId: string, patch: InventoryWebhookPatch): Promise<InventoryWebhook>;
+export declare function deleteWebhook(transport: InternerTransport, webhookId: string): Promise<{
+    webhookId: string;
+    deleted: boolean;
+}>;
+/** Die Webhooks des Kontos und die Ereignisse, die es abonnieren kann. */
+export declare function listWebhooks(transport: InternerTransport): Promise<InventoryWebhookList>;
+/**
+ * Ein neues Secret fuer denselben Webhook. Ab der Antwort gilt nur noch das
+ * neue (keine Uebergangsfrist): erst speichern, dann weiterarbeiten.
+ */
+export declare function rotateWebhookSecret(transport: InternerTransport, webhookId: string): Promise<InventoryWebhookWithSecret>;
+/**
+ * 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`).
+ */
+export declare function sendWebhookTest(transport: InternerTransport, webhookId: string, event: string): Promise<InventoryWebhookTestResult>;
+/** Die letzten Zustellungen, neueste zuerst; mit `webhookId` nur die eines Webhooks. */
+export declare function listWebhookDeliveries(transport: InternerTransport, options?: {
+    webhookId?: string;
+    limit?: number;
+}): Promise<InventoryWebhookDelivery[]>;

package/dist/esm/inventory/endpunkte.js

@@ -0,0 +1,266 @@
+/**
+ * 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]).
+ */
+import { KasseneckValidationError } from '../client/errors.js';
+import { antwortfehler, artikel, bestand, bewegung, liste, naechsterCursor, objekt, probeZustellung, standort, webhook, wert, zustellung, } from './lesen.js';
+import { INVENTORY_LIST_LIMIT_MAX } from './vertrag.js';
+function anfragefehler(name, grund) {
+    return new 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 > INVENTORY_LIST_LIMIT_MAX) {
+            throw anfragefehler(name, `limit muss eine ganze Zahl von 1 bis ${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 antwortfehler(name, 'Antwort nennt denselben nextCursor zweimal');
+        gesehen.add(nextCursor);
+        cursor = nextCursor;
+    }
+}
+// ---- Artikel ------------------------------------------------------------------
+export async function getArticle(transport, articleId) {
+    const name = 'getArticle';
+    const daten = await transport(name, { articleId: kennung(name, 'articleId', articleId) });
+    return artikel({ name, pfad: 'article' }, objekt(daten)?.article);
+}
+export async function listArticles(transport, query) {
+    const name = 'listArticles';
+    const daten = await transport(name, abfrage(name, query));
+    return { articles: liste(name, daten, 'articles', artikel), nextCursor: naechsterCursor(name, daten) };
+}
+/** Alle Artikel der Abfrage, Seite fuer Seite ueber `nextCursor`. */
+export 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`).
+ */
+export 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 artikel({ name, pfad: 'article' }, objekt(daten)?.article);
+}
+// ---- Standorte und Bestand -----------------------------------------------------------
+/** Alle Standorte des Kontos, samt aufgeloesten (`active: false`) und dem Hauptstandort. */
+export async function listLocations(transport) {
+    const name = 'listLocations';
+    return liste(name, await transport(name, {}), 'locations', standort);
+}
+/** Die Werte (`values`): fehlt das Feld, fehlt das Recht `costs` -> `null`, nie `[]`. */
+function werte(name, daten) {
+    const roh = objekt(daten)?.values;
+    if (roh === undefined || roh === null)
+        return null;
+    return liste(name, daten, 'values', wert);
+}
+/** Bestand eines Artikels je Standort. */
+export async function getStock(transport, articleId) {
+    const name = 'getStock';
+    const daten = await transport(name, { articleId: kennung(name, 'articleId', articleId) });
+    return { stock: liste(name, daten, 'stock', bestand), values: werte(name, daten) };
+}
+export async function listStock(transport, query) {
+    const name = 'listStock';
+    const daten = await transport(name, abfrage(name, query));
+    return { stock: liste(name, daten, 'stock', bestand), values: werte(name, daten), nextCursor: naechsterCursor(name, daten) };
+}
+/**
+ * Alle Bestandszeilen der Abfrage, Seite fuer Seite. Die Werte (`values`)
+ * stehen je Seite in [listStock]; der Iterator liefert nur die Zeilen.
+ */
+export 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. */
+export async function listStockMovements(transport, query) {
+    const name = 'listStockMovements';
+    const daten = await transport(name, abfrage(name, query));
+    return { movements: liste(name, daten, 'movements', bewegung), nextCursor: naechsterCursor(name, daten) };
+}
+export 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 = objekt(daten);
+    const secret = o?.secret;
+    if (typeof secret !== 'string' || secret === '') {
+        throw antwortfehler(name, 'Antwort enthaelt kein secret; ohne es laesst sich keine Zustellung pruefen');
+    }
+    return { webhook: 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.
+ */
+export 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. */
+export 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 webhook({ name, pfad: 'webhook' }, objekt(daten)?.webhook);
+}
+export async function deleteWebhook(transport, webhookId) {
+    const name = 'deleteWebhook';
+    const id = kennung(name, 'webhookId', webhookId);
+    const o = 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. */
+export async function listWebhooks(transport) {
+    const name = 'listWebhooks';
+    const daten = await transport(name, {});
+    const ereignisse = objekt(daten)?.events;
+    return {
+        webhooks: liste(name, daten, 'webhooks', 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.
+ */
+export 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`).
+ */
+export 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 = objekt(daten);
+    return {
+        eventId: typeof o?.eventId === 'string' ? o.eventId : '',
+        event: typeof o?.event === 'string' ? o.event : ereignis,
+        deliveries: liste(name, daten, 'deliveries', (ort, e) => probeZustellung(ort, e, id)),
+    };
+}
+/** Die letzten Zustellungen, neueste zuerst; mit `webhookId` nur die eines Webhooks. */
+export 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 liste(name, await transport(name, params), 'deliveries', zustellung);
+}

package/dist/esm/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/esm/inventory/fehler.js

@@ -0,0 +1,40 @@
+/**
+ * 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 { bekannterCode, feldfehlerVon } from '../client/fehlercodes.js';
+import { INVENTORY_ERROR_CODES, INVENTORY_REQUEST_ERROR_CODES, } from './vertrag.js';
+const BEKANNT = new Set([...INVENTORY_ERROR_CODES, ...INVENTORY_REQUEST_ERROR_CODES]);
+export function isInventoryErrorCode(value) {
+    return typeof value === 'string' && BEKANNT.has(value);
+}
+/** Der Fehlercode eines geworfenen Fehlers; `undefined`, wenn es keiner der Lager-API ist. */
+export function inventoryErrorCode(error) {
+    return bekannterCode(error, BEKANNT);
+}
+/** Kurzform fuer `catch (e) { if (isInventoryError(e, 'article_not_found')) … }`. */
+export 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. */
+export function inventoryFieldErrors(error) {
+    return 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).
+ */
+export 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/esm/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/esm/inventory/index.js

@@ -0,0 +1,18 @@
+/**
+ * `@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 } from './api.js';
+export { inventoryKeyAuth } from './auth.js';
+export { isInventoryError, isInventoryErrorCode, inventoryErrorCode, inventoryFieldErrors, inventoryRetryAfterSec, } 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, } from './webhook.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, } from './vertrag.js';

package/dist/esm/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 {};