@kreiseck/kasseneck-api 1.3.0 → 1.5.0

package/dist/esm/inventory/endpunkte.js

@@ -0,0 +1,267 @@
+/**
+ * Die Aufrufe der Lager-API: Artikel, Standorte, Bestand und Bewegungen
+ * lesen, Konto-Webhooks verwalten (Backend Stufe 5a). Die schreibenden
+ * Aufrufe (Stufe 5b) stehen in `schreiben.ts` und teilen die Helfer hier.
+ *
+ * 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';
+export function anfragefehler(name, grund) {
+    return new KasseneckValidationError(name, grund, 'request');
+}
+/** Eine Kennung, die gesendet werden muss: Text mit mindestens einem Zeichen ausser Leerraum. */
+export 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.
+ */
+export 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.
+ */
+export 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,43 @@
+/**
+ * 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 { InventoryShortfall } from './typen.js';
+import { type InventoryErrorCode, type InventoryRequestErrorCode, type InventoryWarningCode } 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;
+/**
+ * Die Positionen, fuer die beim Reservieren der verfuegbare Bestand nicht
+ * reicht (`insufficient_available`, `data.details[]`): je Artikel und Standort
+ * angefragt und verfuegbar, in Tausendstel. Leer, wenn der Fehler ein anderer
+ * ist. Es fehlen nur diese Positionen; reserviert wurde nichts.
+ */
+export declare function inventoryShortfalls(error: unknown): InventoryShortfall[];
+/** `true` fuer einen Hinweis-Code einer Buchung (`warnings[].code`); Hinweise sind nie Fehler. */
+export declare function isInventoryWarningCode(value: unknown): value is InventoryWarningCode;

package/dist/esm/inventory/fehler.js

@@ -0,0 +1,57 @@
+/**
+ * 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 { fehlmengen } from './lesen.js';
+import { INVENTORY_ERROR_CODES, INVENTORY_REQUEST_ERROR_CODES, INVENTORY_WARNING_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;
+}
+/**
+ * Die Positionen, fuer die beim Reservieren der verfuegbare Bestand nicht
+ * reicht (`insufficient_available`, `data.details[]`): je Artikel und Standort
+ * angefragt und verfuegbar, in Tausendstel. Leer, wenn der Fehler ein anderer
+ * ist. Es fehlen nur diese Positionen; reserviert wurde nichts.
+ */
+export function inventoryShortfalls(error) {
+    if (inventoryErrorCode(error) !== 'insufficient_available')
+        return [];
+    return fehlmengen(error.details['details']);
+}
+const HINWEISE = new Set(INVENTORY_WARNING_CODES);
+/** `true` fuer einen Hinweis-Code einer Buchung (`warnings[].code`); Hinweise sind nie Fehler. */
+export function isInventoryWarningCode(value) {
+    return typeof value === 'string' && HINWEISE.has(value);
+}

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

@@ -0,0 +1,21 @@
+/**
+ * `@kreiseck/kasseneck-api/inventory` – die Lager-API: Artikel, Standorte,
+ * Bestand und Lagerprotokoll lesen, Konto-Webhooks verwalten und eingehende
+ * Zustellungen pruefen (Backend Stufe 5a); Artikel anlegen und aendern,
+ * Bestand buchen und Ware reservieren (Stufe 5b, seit 1.5.0).
+ *
+ * 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, inventoryShortfalls, isInventoryWarningCode, 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 { changeStockCondition, createArticle, createReservation, deactivateArticle, extendReservation, getReservation, iterateReservations, listReservations, previewGoodsReceipt, receiveGoods, recordStockLoss, releaseReservation, reverseStockMovement, transferStock, updateArticle, } from './schreiben.js';
+export { verifyInventoryWebhookSignature, parseInventoryWebhookEvent, WEBHOOK_SIGNATURE_HEADER, WEBHOOK_EVENT_HEADER, WEBHOOK_DELIVERY_HEADER, WEBHOOK_TOLERANCE_SEC, type VerifyInventoryWebhookOptions, } from './webhook.js';
+export type { Article, ArticleInput, ArticleListQuery, ArticleLookup, ArticlePage, ChangeStockConditionRequest, CreateArticleRequest, CreateInventoryWebhookOptions, CreateReservationRequest, DeactivateArticleRequest, ExtendReservationRequest, GoodsReceiptItem, GoodsReceiptPreview, GoodsReceiptPreviewLine, GoodsReceiptPreviewRequest, InventoryShortfall, InventoryWarning, InventoryWebhook, InventoryWebhookDelivery, InventoryWebhookEnvelope, InventoryWebhookEvent, InventoryWebhookList, InventoryWebhookPatch, InventoryWebhookTestDelivery, InventoryWebhookTestResult, InventoryWebhookWithSecret, LandedCost, Location, LocationAddress, ReceiveGoodsRequest, RecordStockLossRequest, ReleaseReservationItem, ReleaseReservationRequest, Reservation, ReservationItem, ReservationItemInput, ReservationListQuery, ReservationPage, ReverseStockMovementRequest, StockBelowMinimumEventData, StockChangedEventData, StockItem, StockLevel, StockListQuery, StockMovement, StockMovementLot, StockMovementPage, StockMovementQuery, StockMovementSourceRef, StockOperation, StockPage, StockResult, StockValue, TransferStockRequest, UpdateArticleRequest, } 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, INVENTORY_WARNING_CODES, STOCK_KINDS, STOCK_LOSS_REASONS, WITHDRAWAL_TYPES, LANDED_COST_TYPES, LANDED_COST_ALLOCATIONS, RESERVATION_STATUSES, INVENTORY_IDEMPOTENCY_KEY_MAX, RESERVATION_MINUTES_MIN, RESERVATION_MINUTES_MAX, type InventoryEndpoint, type InventoryErrorCode, type InventoryRequestErrorCode, type InventoryWebhookEventType, type LocationType, type StockMovementType, type StockMovementSource, type StockCondition, type StockChangeCause, type WebhookDeliveryStatus, type InventoryWarningCode, type StockKind, type StockLossReason, type WithdrawalType, type LandedCostType, type LandedCostAllocation, type ReservationStatus, } from './vertrag.js';

package/dist/esm/inventory/index.js

@@ -0,0 +1,20 @@
+/**
+ * `@kreiseck/kasseneck-api/inventory` – die Lager-API: Artikel, Standorte,
+ * Bestand und Lagerprotokoll lesen, Konto-Webhooks verwalten und eingehende
+ * Zustellungen pruefen (Backend Stufe 5a); Artikel anlegen und aendern,
+ * Bestand buchen und Ware reservieren (Stufe 5b, seit 1.5.0).
+ *
+ * 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, inventoryShortfalls, isInventoryWarningCode, } 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 { changeStockCondition, createArticle, createReservation, deactivateArticle, extendReservation, getReservation, iterateReservations, listReservations, previewGoodsReceipt, receiveGoods, recordStockLoss, releaseReservation, reverseStockMovement, transferStock, updateArticle, } from './schreiben.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, INVENTORY_WARNING_CODES, STOCK_KINDS, STOCK_LOSS_REASONS, WITHDRAWAL_TYPES, LANDED_COST_TYPES, LANDED_COST_ALLOCATIONS, RESERVATION_STATUSES, INVENTORY_IDEMPOTENCY_KEY_MAX, RESERVATION_MINUTES_MIN, RESERVATION_MINUTES_MAX, } from './vertrag.js';

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

@@ -0,0 +1,45 @@
+/**
+ * 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, GoodsReceiptPreviewLine, InventoryShortfall, InventoryWebhook, InventoryWebhookDelivery, InventoryWebhookTestDelivery, Location, Reservation, StockBelowMinimumEventData, StockChangedEventData, StockLevel, StockMovement, StockOperation, 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;
+/** Antwort einer Buchung; ohne `operationId` ist nicht belegt, dass gebucht wurde. */
+export declare function vorgang(name: string, daten: unknown): StockOperation;
+/** Eine Zeile der Wareneingangs-Vorschau; Werte nur, wenn der Server sie sendet (Recht `costs`). */
+export declare function vorschauZeile(ort: Ort, w: unknown): GoodsReceiptPreviewLine;
+export declare function reservierung(ort: Ort, w: unknown): Reservation;
+/** Die fehlenden Positionen aus `insufficient_available` (`data.details[]`); ein kaputter Eintrag faellt weg. */
+export declare function fehlmengen(roh: unknown): InventoryShortfall[];
+/** 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 {};