@kreiseck/kasseneck-api 1.4.0 → 1.5.0

package/dist/esm/client/aufrufe.js

@@ -85,6 +85,20 @@ export const ALL_CALLS = [
     'sendWebhookTest',
     'rotateWebhookSecret',
     'listWebhookDeliveries',
+    // Lager-API schreiben und Reservierung (Stufe 5b, ./inventory)
+    'createArticle',
+    'updateArticle',
+    'deactivateArticle',
+    'receiveGoods',
+    'transferStock',
+    'recordStockLoss',
+    'changeStockCondition',
+    'reverseStockMovement',
+    'createReservation',
+    'extendReservation',
+    'releaseReservation',
+    'getReservation',
+    'listReservations',
 ];
 /**
  * Die oeffentlichen Endpunkte unter `/v3` (`https://api.kasseneck.at/v3/<name>`),
@@ -171,6 +185,20 @@ export const PUBLIC_CALLS = [
     'sendWebhookTest',
     'rotateWebhookSecret',
     'listWebhookDeliveries',
+    // Lager-API schreiben und Reservierung (Backend Stufe 5b), umhuellt in `./inventory`.
+    'createArticle',
+    'updateArticle',
+    'deactivateArticle',
+    'receiveGoods',
+    'transferStock',
+    'recordStockLoss',
+    'changeStockCondition',
+    'reverseStockMovement',
+    'createReservation',
+    'extendReservation',
+    'releaseReservation',
+    'getReservation',
+    'listReservations',
 ];
 /**
  * Die Endpunkte des Kassenwegs (`https://kasse.kasseneck.at/api/v3/<name>`,

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

@@ -1,10 +1,10 @@
 /**
- * Fassade ueber den Aufrufen der Lager-API: Schluessel einmal binden, dann
- * rufen. Wie [createInvoiceApi] bewusst keine Klasse; die Aufrufe sind freie
+ * Fassade ueber den Aufrufen der Lager-API (lesen, Webhooks, schreiben,
+ * reservieren): Schluessel einmal binden, dann rufen. Wie [createInvoiceApi] bewusst keine Klasse; die Aufrufe sind freie
  * Funktionen (endpunkte.ts) und bleiben einzeln importierbar.
  */
 import { type FetchLike } from '../client/transport.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';
+import type { Article, ChangeStockConditionRequest, CreateArticleRequest, CreateReservationRequest, DeactivateArticleRequest, ExtendReservationRequest, GoodsReceiptPreview, GoodsReceiptPreviewRequest, ReceiveGoodsRequest, RecordStockLossRequest, ReleaseReservationRequest, Reservation, ReservationListQuery, ReservationPage, ReverseStockMovementRequest, StockOperation, TransferStockRequest, UpdateArticleRequest, ArticleListQuery, ArticleLookup, ArticlePage, CreateInventoryWebhookOptions, InventoryWebhook, InventoryWebhookDelivery, InventoryWebhookList, InventoryWebhookPatch, InventoryWebhookTestResult, InventoryWebhookWithSecret, Location, StockLevel, StockListQuery, StockMovement, StockMovementPage, StockMovementQuery, StockPage, StockResult } from './typen.js';
 import type { InventoryWebhookEventType } from './vertrag.js';
 export interface InventoryClientOptions {
     /** `api_key` des Kontos (`kr_live_…` / `kr_test_…`). Gehoert auf einen Server. */
@@ -41,5 +41,21 @@ export interface InventoryClient {
         webhookId?: string;
         limit?: number;
     }): Promise<InventoryWebhookDelivery[]>;
+    createArticle(request: CreateArticleRequest): Promise<Article>;
+    updateArticle(request: UpdateArticleRequest): Promise<Article>;
+    deactivateArticle(request: DeactivateArticleRequest): Promise<Article>;
+    receiveGoods(request: ReceiveGoodsRequest): Promise<StockOperation>;
+    /** `receiveGoods` mit `dryRun: true`: rechnet, schreibt nichts, Schluessel freigestellt. */
+    previewGoodsReceipt(request: GoodsReceiptPreviewRequest): Promise<GoodsReceiptPreview>;
+    transferStock(request: TransferStockRequest): Promise<StockOperation>;
+    recordStockLoss(request: RecordStockLossRequest): Promise<StockOperation>;
+    changeStockCondition(request: ChangeStockConditionRequest): Promise<StockOperation>;
+    reverseStockMovement(request: ReverseStockMovementRequest): Promise<StockOperation>;
+    createReservation(request: CreateReservationRequest): Promise<Reservation>;
+    extendReservation(request: ExtendReservationRequest): Promise<Reservation>;
+    releaseReservation(request: ReleaseReservationRequest): Promise<Reservation>;
+    getReservation(reservationId: string): Promise<Reservation>;
+    listReservations(query?: ReservationListQuery): Promise<ReservationPage>;
+    iterateReservations(query?: ReservationListQuery): AsyncGenerator<Reservation, void, undefined>;
 }
 export declare function createInventoryClient(options: InventoryClientOptions): InventoryClient;

package/dist/esm/inventory/api.js

@@ -1,11 +1,12 @@
 /**
- * Fassade ueber den Aufrufen der Lager-API: Schluessel einmal binden, dann
- * rufen. Wie [createInvoiceApi] bewusst keine Klasse; die Aufrufe sind freie
+ * Fassade ueber den Aufrufen der Lager-API (lesen, Webhooks, schreiben,
+ * reservieren): Schluessel einmal binden, dann rufen. Wie [createInvoiceApi] bewusst keine Klasse; die Aufrufe sind freie
  * Funktionen (endpunkte.ts) und bleiben einzeln importierbar.
  */
 import { createTransport } from '../client/transport.js';
 import { inventoryKeyAuth } from './auth.js';
 import { createWebhook, deleteWebhook, getArticle, getStock, iterateArticles, iterateStock, iterateStockMovements, listArticles, listLocations, listStock, listStockMovements, listWebhookDeliveries, listWebhooks, lookupArticleByCode, rotateWebhookSecret, sendWebhookTest, updateWebhook, } from './endpunkte.js';
+import { changeStockCondition, createArticle, createReservation, deactivateArticle, extendReservation, getReservation, iterateReservations, listReservations, previewGoodsReceipt, receiveGoods, recordStockLoss, releaseReservation, reverseStockMovement, transferStock, updateArticle, } from './schreiben.js';
 export function createInventoryClient(options) {
     const rufen = createTransport({
         auth: inventoryKeyAuth({ apiKey: options.apiKey }),
@@ -31,5 +32,20 @@ export function createInventoryClient(options) {
         sendWebhookTest: (id, event) => sendWebhookTest(rufen, id, event),
         rotateWebhookSecret: (id) => rotateWebhookSecret(rufen, id),
         listWebhookDeliveries: (o) => listWebhookDeliveries(rufen, o),
+        createArticle: (r) => createArticle(rufen, r),
+        updateArticle: (r) => updateArticle(rufen, r),
+        deactivateArticle: (r) => deactivateArticle(rufen, r),
+        receiveGoods: (r) => receiveGoods(rufen, r),
+        previewGoodsReceipt: (r) => previewGoodsReceipt(rufen, r),
+        transferStock: (r) => transferStock(rufen, r),
+        recordStockLoss: (r) => recordStockLoss(rufen, r),
+        changeStockCondition: (r) => changeStockCondition(rufen, r),
+        reverseStockMovement: (r) => reverseStockMovement(rufen, r),
+        createReservation: (r) => createReservation(rufen, r),
+        extendReservation: (r) => extendReservation(rufen, r),
+        releaseReservation: (r) => releaseReservation(rufen, r),
+        getReservation: (id) => getReservation(rufen, id),
+        listReservations: (q) => listReservations(rufen, q),
+        iterateReservations: (q) => iterateReservations(rufen, q),
     };
 }

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

@@ -1,6 +1,7 @@
 /**
  * Die Aufrufe der Lager-API: Artikel, Standorte, Bestand und Bewegungen
- * lesen, Konto-Webhooks verwalten (Backend Stufe 5a).
+ * 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.
@@ -14,8 +15,26 @@
  * wiederholt werden. Bei `rate_limited` vorher `retryAfterSec` warten
  * ([inventoryRetryAfterSec]).
  */
-import type { InternerTransport } from '../client/aufrufe.js';
+import type { ApiCall, InternerTransport } from '../client/aufrufe.js';
+import { KasseneckValidationError } from '../client/errors.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';
+type Params = Record<string, unknown>;
+export declare function anfragefehler(name: ApiCall, grund: string): KasseneckValidationError;
+/** Eine Kennung, die gesendet werden muss: Text mit mindestens einem Zeichen ausser Leerraum. */
+export declare function kennung(name: ApiCall, feld: string, wert: unknown): string;
+/**
+ * Die Abfrage einer Liste als Parameter. Unbekannte Felder gehen unveraendert
+ * hinaus (der Server weist sie mit `validation` ab), `undefined` faellt weg.
+ */
+export declare function abfrage(name: ApiCall, query: object | undefined): Params;
+/**
+ * Blaettert ueber alle Seiten, Eintrag fuer Eintrag. Derselbe Cursor zweimal
+ * waere eine Endlosschleife: dann endet die Schleife mit einem Antwortfehler.
+ */
+export declare function seitenweise<T>(name: ApiCall, start: string | undefined, seite: (cursor: string | undefined) => Promise<{
+    eintraege: T[];
+    nextCursor: string | null;
+}>): AsyncGenerator<T, void, undefined>;
 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`. */
@@ -69,3 +88,4 @@ export declare function listWebhookDeliveries(transport: InternerTransport, opti
     webhookId?: string;
     limit?: number;
 }): Promise<InventoryWebhookDelivery[]>;
+export {};

package/dist/esm/inventory/endpunkte.js

@@ -1,6 +1,7 @@
 /**
  * Die Aufrufe der Lager-API: Artikel, Standorte, Bestand und Bewegungen
- * lesen, Konto-Webhooks verwalten (Backend Stufe 5a).
+ * 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.
@@ -17,11 +18,11 @@
 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) {
+export 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) {
+export function kennung(name, feld, wert) {
     if (typeof wert !== 'string' || wert.trim() === '')
         throw anfragefehler(name, `${feld} fehlt`);
     return wert;
@@ -32,7 +33,7 @@ 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) {
+export function abfrage(name, query) {
     if (query === undefined || query === null)
         return {};
     if (typeof query !== 'object' || Array.isArray(query))
@@ -63,7 +64,7 @@ function abfrage(name, query) {
  * 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) {
+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)

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

@@ -8,7 +8,8 @@
  * `KasseneckApiError.code`.
  */
 import type { KasseneckApiError } from '../client/errors.js';
-import { type InventoryErrorCode, type InventoryRequestErrorCode } from './vertrag.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;
@@ -31,3 +32,12 @@ export declare function inventoryFieldErrors(error: unknown): InventoryFieldErro
  * 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

@@ -8,7 +8,8 @@
  * `KasseneckApiError.code`.
  */
 import { bekannterCode, feldfehlerVon } from '../client/fehlercodes.js';
-import { INVENTORY_ERROR_CODES, INVENTORY_REQUEST_ERROR_CODES, } from './vertrag.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);
@@ -38,3 +39,19 @@ export function inventoryRetryAfterSec(error) {
     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

@@ -1,7 +1,8 @@
 /**
  * `@kreiseck/kasseneck-api/inventory` – die Lager-API: Artikel, Standorte,
  * Bestand und Lagerprotokoll lesen, Konto-Webhooks verwalten und eingehende
- * Zustellungen pruefen (Backend Stufe 5a).
+ * 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
@@ -12,8 +13,9 @@
  */
 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 { 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, 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';
+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

@@ -1,7 +1,8 @@
 /**
  * `@kreiseck/kasseneck-api/inventory` – die Lager-API: Artikel, Standorte,
  * Bestand und Lagerprotokoll lesen, Konto-Webhooks verwalten und eingehende
- * Zustellungen pruefen (Backend Stufe 5a).
+ * 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
@@ -12,7 +13,8 @@
  */
 export { createInventoryClient } from './api.js';
 export { inventoryKeyAuth } from './auth.js';
-export { isInventoryError, isInventoryErrorCode, inventoryErrorCode, inventoryFieldErrors, inventoryRetryAfterSec, } from './fehler.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, } from './vertrag.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

@@ -12,7 +12,7 @@
  * 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';
+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 {
@@ -31,6 +31,13 @@ export declare function zustellung(ort: Ort, w: unknown): InventoryWebhookDelive
 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. */

package/dist/esm/inventory/lesen.js

@@ -59,6 +59,30 @@ function textAbbildung(w) {
             raus[k] = v;
     return raus;
 }
+/**
+ * Mengen je Standort (`minStockByLocation`): jeder Wert eine Ganzzahl. Fehlt
+ * das Feld (Server vor Stufe 5b), gilt „keiner“ (`{}`).
+ */
+function mengenJeStandort(ort, feld, w) {
+    if (w === undefined || w === null)
+        return {};
+    const o = objekt(w);
+    if (!o)
+        throw antwortfehler(ort.name, `Antwort ist unbrauchbar (data.${ort.pfad}.${feld} ist kein Objekt)`);
+    const raus = {};
+    for (const [k, v] of Object.entries(o))
+        raus[k] = ganzzahl(ort, `${feld}.${k}`, v);
+    return raus;
+}
+/** Eine Liste von Kennungen (`movementIds`, `lotIds`); fehlt sie, ist sie leer. */
+function kennungsliste(ort, feld, w) {
+    if (w === undefined || w === null)
+        return [];
+    if (!Array.isArray(w) || !w.every((x) => typeof x === 'string')) {
+        throw antwortfehler(ort.name, `Antwort ist unbrauchbar (data.${ort.pfad}${ort.pfad ? '.' : ''}${feld} ist keine Liste von Kennungen)`);
+    }
+    return [...w];
+}
 // ---- Artikel ------------------------------------------------------------------
 export function artikel(ort, w) {
     const a = eintrag(ort, w);
@@ -76,6 +100,7 @@ export function artikel(ort, w) {
     const raus = {
         id: kennung(ort, 'id', a.id),
         name: text(a.name),
+        description: text(a.description),
         unitPriceCents: ganzzahlOderNull(ort, 'unitPriceCents', a.unitPriceCents),
         vatRate: typeof vatRate === 'number' ? vatRate : null,
         unit: text(a.unit),
@@ -85,8 +110,10 @@ export function artikel(ort, w) {
         groupId: text(a.groupId),
         revenueGroupId: text(a.revenueGroupId),
         stockTracked: a.stockTracked === true,
+        stockKind: textOderNull(a.stockKind),
         stockLocationIds: standorte,
         minStock: ganzzahlOderNull(ort, 'minStock', a.minStock),
+        minStockByLocation: mengenJeStandort(ort, 'minStockByLocation', a.minStockByLocation),
         active: a.active !== false,
         createdAt: text(a.createdAt),
         updatedAt: text(a.updatedAt),
@@ -173,8 +200,14 @@ export function bewegung(ort, w) {
         locationId: text(b.locationId),
         condition: text(b.condition),
         quantityDelta: ganzzahl(ort, 'quantityDelta', b.quantityDelta),
+        // Server vor Stufe 5b senden das Feld nicht: dort aenderte keine Bewegung `reserved`.
+        reservedDelta: b.reservedDelta === undefined ? 0 : ganzzahl(ort, 'reservedDelta', b.reservedDelta),
         stockAfter: nachher
-            ? { sellable: ganzzahl(nachherOrt, 'sellable', nachher.sellable), defective: ganzzahl(nachherOrt, 'defective', nachher.defective) }
+            ? {
+                sellable: ganzzahl(nachherOrt, 'sellable', nachher.sellable),
+                defective: ganzzahl(nachherOrt, 'defective', nachher.defective),
+                reserved: ganzzahlOderNull(nachherOrt, 'reserved', nachher.reserved),
+            }
             : null,
         operationId: text(b.operationId),
         source: quelle
@@ -255,6 +288,99 @@ export function unterMindestbestand(ort, w) {
         minStock: ganzzahl(ort, 'minStock', d.minStock),
     };
 }
+// ---- Schreiben (Stufe 5b) ------------------------------------------------------------
+function warnung(ort, w) {
+    const h = eintrag(ort, w);
+    if (typeof h.code !== 'string' || h.code === '')
+        throw antwortfehler(ort.name, `Hinweis ohne Code (data.${ort.pfad}.code)`);
+    return {
+        code: h.code,
+        articleId: textOderNull(h.articleId),
+        locationId: textOderNull(h.locationId),
+        message: typeof h.message === 'string' ? h.message : '',
+    };
+}
+/** Antwort einer Buchung; ohne `operationId` ist nicht belegt, dass gebucht wurde. */
+export function vorgang(name, daten) {
+    const d = objekt(daten);
+    if (!d)
+        throw antwortfehler(name, 'Antwort ist unbrauchbar (data ist kein Objekt)');
+    const ort = { name, pfad: '' };
+    if (typeof d.operationId !== 'string' || d.operationId === '') {
+        throw antwortfehler(name, 'Antwort enthaelt keine Kennung (data.operationId fehlt)');
+    }
+    const hinweise = d.warnings === undefined || d.warnings === null ? [] : d.warnings;
+    if (!Array.isArray(hinweise))
+        throw antwortfehler(name, 'Antwort ist unbrauchbar (data.warnings ist keine Liste)');
+    return {
+        operationId: d.operationId,
+        movementIds: kennungsliste(ort, 'movementIds', d.movementIds),
+        lotIds: kennungsliste(ort, 'lotIds', d.lotIds),
+        warnings: hinweise.map((h, i) => warnung({ name, pfad: `warnings[${i}]` }, h)),
+    };
+}
+/** Eine Zeile der Wareneingangs-Vorschau; Werte nur, wenn der Server sie sendet (Recht `costs`). */
+export function vorschauZeile(ort, w) {
+    const z = eintrag(ort, w);
+    const serien = z.serialNumbers === undefined || z.serialNumbers === null ? [] : z.serialNumbers;
+    if (!Array.isArray(serien) || !serien.every((x) => typeof x === 'string')) {
+        throw antwortfehler(ort.name, `Antwort ist unbrauchbar (data.${ort.pfad}.serialNumbers ist keine Liste)`);
+    }
+    const raus = {
+        articleId: kennung(ort, 'articleId', z.articleId),
+        quantity: ganzzahl(ort, 'quantity', z.quantity),
+        expiresOn: textOderNull(z.expiresOn),
+        batch: textOderNull(z.batch),
+        serialNumbers: [...serien],
+        priceFromArticle: z.priceFromArticle === true,
+    };
+    for (const feld of ['baseCents', 'landedCostCents', 'valueCents', 'unitCostMicros']) {
+        if (hat(z, feld))
+            raus[feld] = ganzzahlOderNull(ort, feld, z[feld]);
+    }
+    return raus;
+}
+function reservierungsPosition(ort, w) {
+    const p = eintrag(ort, w);
+    return {
+        articleId: kennung(ort, 'articleId', p.articleId),
+        locationId: kennung(ort, 'locationId', p.locationId),
+        quantity: ganzzahl(ort, 'quantity', p.quantity),
+        redeemed: ganzzahl(ort, 'redeemed', p.redeemed),
+        released: ganzzahl(ort, 'released', p.released),
+    };
+}
+export function reservierung(ort, w) {
+    const r = eintrag(ort, w);
+    if (!Array.isArray(r.items))
+        throw antwortfehler(ort.name, `Antwort ist unbrauchbar (data.${ort.pfad}.items ist keine Liste)`);
+    return {
+        id: kennung(ort, 'id', r.id),
+        status: textOderNull(r.status),
+        reference: text(r.reference),
+        items: r.items.map((p, i) => reservierungsPosition({ name: ort.name, pfad: `${ort.pfad}.items[${i}]` }, p)),
+        expiresAt: text(r.expiresAt),
+        createdAt: text(r.createdAt),
+    };
+}
+/** Die fehlenden Positionen aus `insufficient_available` (`data.details[]`); ein kaputter Eintrag faellt weg. */
+export function fehlmengen(roh) {
+    if (!Array.isArray(roh))
+        return [];
+    const raus = [];
+    for (const e of roh) {
+        const o = objekt(e);
+        if (!o)
+            continue;
+        const { articleId, locationId, requested, available } = o;
+        if (typeof articleId !== 'string' || typeof locationId !== 'string')
+            continue;
+        if (!Number.isSafeInteger(requested) || !Number.isSafeInteger(available))
+            continue;
+        raus.push({ articleId, locationId, requested: requested, available: available });
+    }
+    return raus;
+}
 // ---- Listen ------------------------------------------------------------------
 /** Eine zugesagte Liste `data.<feld>`, Eintrag fuer Eintrag gelesen. */
 export function liste(name, daten, feld, lesen) {

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

@@ -0,0 +1,83 @@
+/**
+ * Die schreibenden Aufrufe der Lager-API (Backend Stufe 5b): Artikel anlegen,
+ * aendern und stilllegen, Bestand buchen (Wareneingang, Umbuchung, Abgang,
+ * Zustand, Gegenbuchung) und reservieren.
+ *
+ * Wie in `endpunkte.ts` nimmt jede Funktion den Transport als ersten Parameter
+ * und ist einzeln importierbar. Die Anfrage geht flach hinaus, genau mit den
+ * Feldern, die der Aufrufer nennt (`undefined` faellt weg, `null` bleibt: es
+ * leert ein Feld bzw. heisst bei der Anlage „nicht angegeben“).
+ *
+ * **Vor dem Senden geprueft wird nur, was ohne Netz sicher falsch ist:**
+ * - `idempotencyKey` fehlt, ist leer oder laenger als 120 Zeichen. Ohne
+ *   Schluessel gaebe es keine sichere Wiederholung, und der Server wiese die
+ *   Anfrage ohnehin ab (`idempotency_key_required` bzw. `validation`);
+ * - eine Pflichtkennung fehlt oder ist leer;
+ * - eine Menge, ein Betrag oder ein Preis ist keine Ganzzahl (Tausendstel,
+ *   Cent, Mikro-Euro): `1.5` waere nie „1,5 Stueck“, sondern ein Fehler;
+ * - `expiresInMinutes` liegt ausserhalb 5 … 43 200;
+ * - eine Aenderung nennt kein Feld, eine Freigabe eine leere Liste.
+ * Alles Fachliche (Pruefziffer der EAN, Kataloge, Bestand, Rechte) prueft der
+ * Server und meldet es mit seinem Code.
+ *
+ * **Wiederholen:** nach einem Zeitlimit oder Netzfehler denselben Aufruf mit
+ * **demselben** `idempotencyKey` noch einmal senden. Er wirkt genau einmal und
+ * liefert die gespeicherte Antwort; ein neuer Schluessel buchte ein zweites Mal.
+ */
+import type { InternerTransport } from '../client/aufrufe.js';
+import type { Article, ChangeStockConditionRequest, CreateArticleRequest, CreateReservationRequest, DeactivateArticleRequest, ExtendReservationRequest, GoodsReceiptPreview, GoodsReceiptPreviewRequest, ReceiveGoodsRequest, RecordStockLossRequest, ReleaseReservationRequest, Reservation, ReservationListQuery, ReservationPage, ReverseStockMovementRequest, StockOperation, TransferStockRequest, UpdateArticleRequest } from './typen.js';
+/**
+ * Legt einen Artikel an. Mit `ean` ein Fremdartikel mit diesem Code (gueltige
+ * Pruefziffer, frei im Konto), sonst vergibt der Server den naechsten eigenen
+ * Code. Antwort: der Artikel wie `getArticle`.
+ */
+export declare function createArticle(transport: InternerTransport, request: CreateArticleRequest): Promise<Article>;
+/** Aendert nur die genannten Felder eines Artikels (siehe [UpdateArticleRequest]). */
+export declare function updateArticle(transport: InternerTransport, request: UpdateArticleRequest): Promise<Article>;
+/** Legt einen Artikel still (`active: false`); Code und eigene Kennungen werden frei. */
+export declare function deactivateArticle(transport: InternerTransport, request: DeactivateArticleRequest): Promise<Article>;
+/**
+ * Bucht einen Wareneingang. Ohne `locationId` am Standard-Standort; die
+ * Antwort traegt keine Werte, auch mit dem Recht `costs` nicht. Fuer die
+ * Vorschau mit Werten: [previewGoodsReceipt].
+ */
+export declare function receiveGoods(transport: InternerTransport, request: ReceiveGoodsRequest): Promise<StockOperation>;
+/**
+ * Vorschau eines Wareneingangs (`receiveGoods` mit `dryRun: true`): prueft
+ * Positionen, Artikel, Preise und Nebenkosten und rechnet die Verteilung,
+ * schreibt aber nichts. Ein `idempotencyKey` ist freigestellt (`null` wie nicht
+ * angegeben, geht nicht hinaus) und wird nicht verbraucht; dieselbe Anfrage
+ * laesst sich danach mit ihm buchen. Werte
+ * (`baseCents` …) nur mit dem Recht `costs`. Den Standort prueft erst die Buchung.
+ */
+export declare function previewGoodsReceipt(transport: InternerTransport, request: GoodsReceiptPreviewRequest): Promise<GoodsReceiptPreview>;
+/** Bucht Ware von einem Standort an einen anderen; ueberzieht nie (`exceeds_stock`). */
+export declare function transferStock(transport: InternerTransport, request: TransferStockRequest): Promise<StockOperation>;
+/** Bucht einen Abgang (Bruch, Schwund, Diebstahl, Entnahme …); ueberzieht nie (`exceeds_stock`). */
+export declare function recordStockLoss(transport: InternerTransport, request: RecordStockLossRequest): Promise<StockOperation>;
+/** Bucht Ware zwischen `sellable` und `defective` um; ueberzieht nie (`exceeds_stock`). */
+export declare function changeStockCondition(transport: InternerTransport, request: ChangeStockConditionRequest): Promise<StockOperation>;
+/** Nimmt einen ganzen Vorgang (`operationId`) mit einer Gegenbuchung zurueck. */
+export declare function reverseStockMovement(transport: InternerTransport, request: ReverseStockMovementRequest): Promise<StockOperation>;
+/**
+ * Reserviert Ware (Checkout im Shop): ganz oder gar nicht, gemessen am
+ * verfuegbaren Bestand (`onHand − reserved`). Fehlt etwas, entsteht nichts:
+ * `insufficient_available`, die fehlenden Positionen in [inventoryShortfalls].
+ * Eingeloest wird ueber eine Rechnung (`issueInvoice` mit `items[].reservationId`),
+ * sonst laeuft die Reservierung ab und gibt die Ware wieder frei.
+ */
+export declare function createReservation(transport: InternerTransport, request: CreateReservationRequest): Promise<Reservation>;
+/** Verlaengert eine aktive Reservierung: neuer Ablauf = jetzt + `expiresInMinutes`. */
+export declare function extendReservation(transport: InternerTransport, request: ExtendReservationRequest): Promise<Reservation>;
+/**
+ * Gibt reservierte Ware frei: ohne `items` alles, sonst je Position (ohne
+ * `quantity` der ganze offene Rest). Die Antwort traegt den Stand danach;
+ * `released` wird der Status erst, wenn nichts mehr offen ist.
+ */
+export declare function releaseReservation(transport: InternerTransport, request: ReleaseReservationRequest): Promise<Reservation>;
+/** Eine Reservierung mit ihrem aktuellen Stand. */
+export declare function getReservation(transport: InternerTransport, reservationId: string): Promise<Reservation>;
+/** Reservierungen, neueste zuerst; Filter `status` und/oder `reference`. */
+export declare function listReservations(transport: InternerTransport, query?: ReservationListQuery): Promise<ReservationPage>;
+/** Alle Reservierungen der Abfrage, Seite fuer Seite ueber `nextCursor`. */
+export declare function iterateReservations(transport: InternerTransport, query?: ReservationListQuery): AsyncGenerator<Reservation, void, undefined>;