@kreiseck/kasseneck-api 1.7.1 → 1.8.0

package/dist/esm/inventory/vertrag.js

@@ -1,17 +1,19 @@
 /**
  * Der Vertrag der Lager-API (Backend Stufe 5a lesen, 5b schreiben und
- * reservieren, 5c Varianten) als Daten: Endpunkte, Wertkataloge, Ereignisse, Fehler- und
- * Hinweiscodes, englisch wie am Draht `/v3`.
+ * reservieren, 5c Varianten, Lager-Kern Stufe 3 Inventur) als Daten:
+ * Endpunkte, Wertkataloge, Ereignisse, Fehler- und Hinweiscodes, englisch wie
+ * am Draht `/v3`.
  *
  * Quelle ist der Vertrags-Export des Backends (`fixtures/v3/v3-vokabular.json`):
  * `endpoints.public`, die Kataloge `STANDORT_TYP`, `BEWEGUNG_ART`,
  * `BEWEGUNG_QUELLE`, `LAGER_ZUSTAND`, `LAGER_URSACHE`, `ZUSTELLUNG`,
  * `LAGER_ABGANG_GRUND`, `LAGER_ENTNAHME_ART`, `LAGER_NEBENKOSTEN_ART`,
- * `LAGER_VERTEILUNG`, `RESERVIERUNG_STATUS`, dazu `events`, `errorCodes.inventory`
+ * `LAGER_VERTEILUNG`, `RESERVIERUNG_STATUS`, die Inventur-Kataloge `INVENTUR_*`,
+ * dazu `events`, `errorCodes.inventory`
  * und `warningCodes.inventory`. `test/inventory.test.ts` haelt jede Liste
  * deckungsgleich mit dieser Datei; nichts hier wird geraten.
  */
-/** Die 32 Endpunkte (14 aus 5a, 13 aus 5b, 5 aus 5c), in der Reihenfolge von `endpoints.public`. */
+/** Die 44 Endpunkte (14 aus 5a, 13 aus 5b, 5 aus 5c, 12 der Inventur), in der Reihenfolge von `endpoints.public`. */
 export const INVENTORY_ENDPOINTS = [
     'getArticle',
     'listArticles',
@@ -45,6 +47,18 @@ export const INVENTORY_ENDPOINTS = [
     'getVariantGroup',
     'listVariantGroups',
     'addVariant',
+    'createStocktake',
+    'listStocktakes',
+    'getStocktake',
+    'listStocktakeItems',
+    'recordStocktakeCount',
+    'voidStocktakeCount',
+    'listStocktakeCounts',
+    'reviewStocktake',
+    'recountStocktake',
+    'closeStocktake',
+    'cancelStocktake',
+    'getStocktakePdf',
 ];
 /** Art eines Standorts (Katalog `STANDORT_TYP`). */
 export const LOCATION_TYPES = ['warehouse', 'store', 'vehicle', 'other'];
@@ -174,6 +188,22 @@ export const INVENTORY_LIST_LIMIT_MAX = 200;
  * `too_many_positions` traegt bei Varianten `field` (`variants`,
  * `createMatrix` bzw. `externalIds` bei `addVariant`): die Anfrage braeuchte
  * mehr Schreibvorgaenge, als in einen Vorgang passen; geschrieben wurde nichts.
+ *
+ * Seit 1.8.0 dahinter die Codes der Inventur: `stocktake_not_found`,
+ * `stocktake_not_open` (Zaehlen oder Stornieren ausserhalb der Zaehlung bzw.
+ * an einer Position, die nicht zum Nachzaehlen frei ist), `stocktake_closed`
+ * (abgeschlossen oder abgebrochen: nichts mehr schreibbar),
+ * `stocktake_not_in_review` (Nachzaehlen und Abschluss nur in `review`),
+ * `stocktake_closing` (der Abschluss bucht gerade), `stocktake_location_busy`
+ * (am Standort laeuft schon eine Inventur; `data.stocktakeId` nennt sie),
+ * `stocktake_review_running` (die Pruefung rechnet noch), `stocktake_recount_open`
+ * (Abschluss, solange Positionen zum Nachzaehlen offen sind: erst nachzaehlen,
+ * dann erneut pruefen), `article_not_in_scope`, `article_not_tracked`,
+ * `count_not_found`, `count_already_voided`, `serial_already_counted` (dieselbe
+ * Seriennummer zweimal in einer Runde), `too_many_counts` (mehr als
+ * [STOCKTAKE_COUNTS_PER_ITEM_MAX] Zaehlungen je Position und Runde) und
+ * `stocktake_not_closed` (das Protokoll gibt es erst nach dem Abschluss, auch
+ * nicht fuer eine abgebrochene Inventur).
  */
 export const INVENTORY_ERROR_CODES = [
     'validation',
@@ -242,6 +272,21 @@ export const INVENTORY_ERROR_CODES = [
     'invalid_variant_attributes',
     'variant_group_inactive',
     'variant_limit',
+    'stocktake_not_found',
+    'stocktake_not_open',
+    'stocktake_closed',
+    'stocktake_not_in_review',
+    'stocktake_closing',
+    'stocktake_location_busy',
+    'stocktake_review_running',
+    'stocktake_recount_open',
+    'article_not_in_scope',
+    'article_not_tracked',
+    'count_not_found',
+    'count_already_voided',
+    'serial_already_counted',
+    'too_many_counts',
+    'stocktake_not_closed',
 ];
 /**
  * Codes, die Anmeldung und Rand auf jedem Lager-Aufruf erzeugen koennen,
@@ -254,6 +299,8 @@ export const INVENTORY_REQUEST_ERROR_CODES = [
     'account_not_found',
     'admin_required',
     'api_not_approved',
+    'app_check_invalid',
+    'app_check_missing',
     'cashregister_not_assigned',
     'cashregister_not_found',
     'cashregister_token_invalid',
@@ -283,12 +330,24 @@ export const INVENTORY_REQUEST_ERROR_CODES = [
  * `below_minimum` misst am verfuegbaren Bestand (`onHand − reserved`) gegen den
  * Mindestbestand des Standorts, `reservation_exceeded` meldet eine Rechnung, die
  * mehr verkauft als reserviert war.
+ *
+ * Seit 1.8.0 die Hinweise der Inventur, je mit der Zahl der Positionen
+ * (`items`): `defect_capped` (eine Fehlmenge im Zustand `defective` reichte
+ * ueber den Defektbestand, der Rest blieb ungebucht), `uncounted_items` (nicht
+ * gezaehlt und darum nicht gebucht), `not_booked` (nicht oder nicht ganz
+ * gebucht, Grund an der Position, `notBooked`) und `recount_uncounted`
+ * (Positionen zum Nachzaehlen blieben ungezaehlt; die Antwort von
+ * `closeStocktake` traegt ihn).
  */
 export const INVENTORY_WARNING_CODES = [
     'insufficient_stock',
     'below_minimum',
     'return_exceeds_sale',
     'reservation_exceeded',
+    'defect_capped',
+    'uncounted_items',
+    'not_booked',
+    'recount_uncounted',
 ];
 /**
  * Bestandsart eines Artikels (`stockKind`): `quantity` = Menge, `serial` =
@@ -334,3 +393,56 @@ export const VARIANT_ATTRIBUTES_MAX = 3;
 export const VARIANT_VALUES_MAX = 30;
 export const VARIANT_MATRIX_MAX = 100;
 export const VARIANT_GROUP_ACTIVE_MAX = 250;
+// ---- Inventur (Lager-Kern Stufe 3, seit 1.8.0) ----------------------------------
+/**
+ * Stand einer Inventur (Katalog `INVENTUR_STATUS`). Gezaehlt wird in
+ * `counting`; `review` rechnet Soll und Differenz (erst ab hier sichtbar,
+ * blind); `closing` bucht den Abschluss in Teilen; `closed` und `cancelled`
+ * sind endgueltig. `creating` steht nur, solange eine grosse Anlage ihre
+ * Positionen schreibt.
+ */
+export const STOCKTAKE_STATUSES = ['creating', 'counting', 'review', 'closing', 'closed', 'cancelled'];
+/**
+ * Art einer Inventur (Katalog `INVENTUR_ART`): `key_date` zu einem Stichtag
+ * (`keyDate`), `perpetual` (permanente Inventur, ohne Stichtag).
+ */
+export const STOCKTAKE_TYPES = ['key_date', 'perpetual'];
+/** Umfang einer Inventur (Katalog `INVENTUR_UMFANG`): alle bestandsgefuehrten Artikel des Standorts, Artikelgruppen oder genannte Artikel. */
+export const STOCKTAKE_SCOPE_TYPES = ['all', 'groups', 'articles'];
+/**
+ * Warum eine Position in der Pruefung „pruefen“ traegt (Katalog
+ * `INVENTUR_PRUEFGRUND`): Bewegung zwischen der ersten und letzten Zaehlung,
+ * Zaehlung mehr als 10 Tage vom Stichtag, Seriennummern weichen ab, nicht gezaehlt.
+ */
+export const STOCKTAKE_CHECK_REASONS = ['movements_between_counts', 'far_from_key_date', 'serial_mismatch', 'not_counted'];
+/**
+ * Warum eine Position nicht oder nicht ganz gebucht wurde (`notBooked.code`,
+ * Katalog `INVENTUR_NICHT_GEBUCHT`). Dazu kommen Codes, die schon englisch
+ * sind (`serial_not_in_stock`, `serial_already_exists`, `article_not_found`);
+ * das Modell laesst darum jeden Text stehen.
+ */
+export const STOCKTAKE_NOT_BOOKED_REASONS = ['serial_mismatch', 'recount_open', 'defect_capped'];
+/** Woher eine Zaehlung bzw. Inventur kam (Katalog `INVENTUR_QUELLE`). */
+export const STOCKTAKE_SOURCES = ['register', 'panel', 'api'];
+/** Wer handelte (Katalog `INVENTUR_AKTEUR`): Inhaber, Kasseneck-Admin, Kassen-Benutzer, API-Schluessel. */
+export const STOCKTAKE_ACTOR_TYPES = ['owner', 'admin', 'register_user', 'api'];
+/**
+ * Zu welchem Zeitpunkt das Inventar im Protokoll steht (Katalog
+ * `INVENTUR_INVENTAR_ZUM`): `key_date` (auf das Ende des Stichtags
+ * fortgeschrieben, Abschluss nach dem Stichtag) oder `count_date` (Menge zur
+ * Aufnahme: permanente Inventur oder Abschluss vor dem Stichtag).
+ */
+export const STOCKTAKE_INVENTORY_AS_OF = ['key_date', 'count_date'];
+/**
+ * Grenzen einer Inventur, wie das Backend sie prueft. Wie bei den Varianten
+ * prueft das Paket sie **nicht** vor dem Senden:
+ *
+ * - [STOCKTAKE_ITEMS_MAX] Positionen je Inventur (`too_many_positions`;
+ *   groessere Bestaende in mehreren Inventuren nacheinander),
+ * - [STOCKTAKE_RECOUNT_ITEMS_MAX] Positionen je `recountStocktake`,
+ * - [STOCKTAKE_COUNTS_PER_ITEM_MAX] Zaehlungen je Position und Runde
+ *   (`too_many_counts`), hoechstens so viele Seriennummern je Zaehlung.
+ */
+export const STOCKTAKE_ITEMS_MAX = 5000;
+export const STOCKTAKE_RECOUNT_ITEMS_MAX = 200;
+export const STOCKTAKE_COUNTS_PER_ITEM_MAX = 200;

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

@@ -37,7 +37,7 @@ export type InvoiceErrorCode = (typeof INVOICE_ERROR_CODES)[number];
  * genau der Katalog des Servers (das Backend vergleicht ihn mit dem Schema);
  * die Helfer in `./invoice` erkennen beide Listen.
  */
-export declare const INVOICE_REQUEST_ERROR_CODES: readonly ["account_not_found", "admin_required", "api_not_approved", "cashregister_not_assigned", "cashregister_not_found", "cashregister_token_invalid", "cashregister_token_missing", "dialect_mismatch", "internal_translation_error", "live_not_enabled", "method_not_allowed", "mfa_required", "not_found", "register_user_no_business", "register_user_not_allowed", "register_user_not_found", "response_translation_failed", "session_expired", "session_other_cashregister", "unauthorized", "user_disabled", "user_verification_failed", "route_missing"];
+export declare const INVOICE_REQUEST_ERROR_CODES: readonly ["account_not_found", "admin_required", "api_not_approved", "app_check_invalid", "app_check_missing", "cashregister_not_assigned", "cashregister_not_found", "cashregister_token_invalid", "cashregister_token_missing", "dialect_mismatch", "internal_translation_error", "live_not_enabled", "method_not_allowed", "mfa_required", "not_found", "register_user_no_business", "register_user_not_allowed", "register_user_not_found", "response_translation_failed", "session_expired", "session_other_cashregister", "unauthorized", "user_disabled", "user_verification_failed", "route_missing"];
 export type InvoiceRequestErrorCode = (typeof INVOICE_REQUEST_ERROR_CODES)[number];
 /** Gruende einer Gutschrift. Der Server druckt den deutschen Anzeigetext. */
 export declare const CREDIT_NOTE_REASONS: readonly ["cancellation", "price_reduction", "return", "incorrect_invoice", "other"];

package/dist/esm/invoice/vertrag.js

@@ -90,6 +90,8 @@ export const INVOICE_REQUEST_ERROR_CODES = [
     'account_not_found',
     'admin_required',
     'api_not_approved',
+    'app_check_invalid',
+    'app_check_missing',
     'cashregister_not_assigned',
     'cashregister_not_found',
     'cashregister_token_invalid',

package/dist/esm/models/cancellation.d.ts

@@ -53,7 +53,7 @@ export declare function isReturnDisposition(value: unknown): value is ReturnDisp
  * [PAYMENT_ERROR_CODES]. Ein Code ausserhalb bleibt ueber
  * `KasseneckApiError.code` lesbar.
  */
-export declare const CANCELLATION_ERROR_CODES: readonly ["receipt_not_found", "receipt_type_not_cancellable", "training_receipt", "already_cancelled", "invalid_line", "quantity_exceeds_remaining", "unknown_reason", "note_too_long", "invalid_items", "cashregister_not_assigned", "not_permitted", "own_receipts_only", "cashregister_incomplete", "cancellation_failed", "cancellation_payments_required", "cancellation_refund_exceeds_payment", "cancellation_refund_reference_required", "cancellation_refund_reference_unknown", "cancellation_outcome_unknown", "invalid_return_disposition", "account_not_found", "admin_required", "api_not_approved", "cashregister_not_found", "cashregister_token_invalid", "cashregister_token_missing", "dialect_mismatch", "internal_translation_error", "live_not_enabled", "method_not_allowed", "mfa_required", "not_found", "register_user_no_business", "register_user_not_allowed", "register_user_not_found", "response_translation_failed", "session_expired", "session_other_cashregister", "unauthorized", "user_disabled", "user_verification_failed", "validation", "route_missing", "response_unreadable"];
+export declare const CANCELLATION_ERROR_CODES: readonly ["receipt_not_found", "receipt_type_not_cancellable", "training_receipt", "already_cancelled", "invalid_line", "quantity_exceeds_remaining", "unknown_reason", "note_too_long", "invalid_items", "cashregister_not_assigned", "not_permitted", "own_receipts_only", "cashregister_incomplete", "cancellation_failed", "cancellation_payments_required", "cancellation_refund_exceeds_payment", "cancellation_refund_reference_required", "cancellation_refund_reference_unknown", "cancellation_outcome_unknown", "invalid_return_disposition", "account_not_found", "admin_required", "api_not_approved", "app_check_invalid", "app_check_missing", "cashregister_not_found", "cashregister_token_invalid", "cashregister_token_missing", "dialect_mismatch", "internal_translation_error", "live_not_enabled", "method_not_allowed", "mfa_required", "not_found", "register_user_no_business", "register_user_not_allowed", "register_user_not_found", "response_translation_failed", "session_expired", "session_other_cashregister", "unauthorized", "user_disabled", "user_verification_failed", "validation", "route_missing", "response_unreadable"];
 export type CancellationErrorCode = (typeof CANCELLATION_ERROR_CODES)[number];
 export declare function isCancellationErrorCode(value: unknown): value is CancellationErrorCode;
 /** Der Code eines geworfenen Fehlers, wenn er in [CANCELLATION_ERROR_CODES] steht; sonst `undefined`. */

package/dist/esm/models/cancellation.js

@@ -79,6 +79,8 @@ export const CANCELLATION_ERROR_CODES = Object.freeze([
     'account_not_found',
     'admin_required',
     'api_not_approved',
+    'app_check_invalid',
+    'app_check_missing',
     'cashregister_not_found',
     'cashregister_token_invalid',
     'cashregister_token_missing',

package/dist/esm/models/payment-errors.d.ts

@@ -19,7 +19,7 @@ import { KasseneckApiError } from '../client/errors.js';
  * ...) und zuletzt `route_missing` (Code des Pakets). Ein Code ausserhalb
  * bleibt ueber `KasseneckApiError.code` lesbar.
  */
-export declare const PAYMENT_ERROR_CODES: readonly ["payments_invalid", "payment_method_invalid", "payment_amount_invalid", "payment_tendered_invalid", "payment_provider_invalid", "payment_provider_not_allowed", "payments_sum_mismatch", "payments_due_negative", "payments_not_allowed", "payments_conflict", "payments_required", "payment_method_not_supported", "tip_payment_method_invalid", "tip_payment_method_required", "tip_exceeds_payment", "payment_refund_not_allowed", "payment_tip_invalid", "tip_conflict", "account_not_found", "admin_required", "api_not_approved", "cashregister_not_assigned", "cashregister_not_found", "cashregister_token_invalid", "cashregister_token_missing", "dialect_mismatch", "internal_translation_error", "live_not_enabled", "method_not_allowed", "mfa_required", "not_found", "register_user_no_business", "register_user_not_allowed", "register_user_not_found", "response_translation_failed", "session_expired", "session_other_cashregister", "unauthorized", "user_disabled", "user_verification_failed", "validation", "route_missing"];
+export declare const PAYMENT_ERROR_CODES: readonly ["payments_invalid", "payment_method_invalid", "payment_amount_invalid", "payment_tendered_invalid", "payment_provider_invalid", "payment_provider_not_allowed", "payments_sum_mismatch", "payments_due_negative", "payments_not_allowed", "payments_conflict", "payments_required", "payment_method_not_supported", "tip_payment_method_invalid", "tip_payment_method_required", "tip_exceeds_payment", "payment_refund_not_allowed", "payment_tip_invalid", "tip_conflict", "account_not_found", "admin_required", "api_not_approved", "app_check_invalid", "app_check_missing", "cashregister_not_assigned", "cashregister_not_found", "cashregister_token_invalid", "cashregister_token_missing", "dialect_mismatch", "internal_translation_error", "live_not_enabled", "method_not_allowed", "mfa_required", "not_found", "register_user_no_business", "register_user_not_allowed", "register_user_not_found", "response_translation_failed", "session_expired", "session_other_cashregister", "unauthorized", "user_disabled", "user_verification_failed", "validation", "route_missing"];
 export type PaymentErrorCode = (typeof PAYMENT_ERROR_CODES)[number];
 /** Erkennt einen Code aus [PAYMENT_ERROR_CODES], exakt (klein, wie unter `/v3`). */
 export declare function isPaymentErrorCode(value: unknown): value is PaymentErrorCode;

package/dist/esm/models/payment-errors.js

@@ -42,6 +42,8 @@ export const PAYMENT_ERROR_CODES = Object.freeze([
     'account_not_found',
     'admin_required',
     'api_not_approved',
+    'app_check_invalid',
+    'app_check_missing',
     'cashregister_not_assigned',
     'cashregister_not_found',
     'cashregister_token_invalid',

package/dist/esm/models/receipt-email.d.ts

@@ -11,7 +11,7 @@ export type ReceiptEmailSendErrorCode = (typeof RECEIPT_EMAIL_SEND_ERROR_CODES)[
  * als [KasseneckApiError.code] durch; ein Code ausserhalb bleibt dort lesbar.
  * Zuletzt `route_missing` (Code des Pakets).
  */
-export declare const RECEIPT_EMAIL_ERROR_CODES: readonly ["invalid_address", "receipt_not_found", "too_many_requests", "send_failed", "account_not_found", "admin_required", "api_not_approved", "cashregister_not_assigned", "cashregister_not_found", "cashregister_token_invalid", "cashregister_token_missing", "dialect_mismatch", "internal_translation_error", "live_not_enabled", "method_not_allowed", "mfa_required", "not_found", "register_user_no_business", "register_user_not_allowed", "register_user_not_found", "response_translation_failed", "session_expired", "session_other_cashregister", "unauthorized", "user_disabled", "user_verification_failed", "validation", "route_missing"];
+export declare const RECEIPT_EMAIL_ERROR_CODES: readonly ["invalid_address", "receipt_not_found", "too_many_requests", "send_failed", "account_not_found", "admin_required", "api_not_approved", "app_check_invalid", "app_check_missing", "cashregister_not_assigned", "cashregister_not_found", "cashregister_token_invalid", "cashregister_token_missing", "dialect_mismatch", "internal_translation_error", "live_not_enabled", "method_not_allowed", "mfa_required", "not_found", "register_user_no_business", "register_user_not_allowed", "register_user_not_found", "response_translation_failed", "session_expired", "session_other_cashregister", "unauthorized", "user_disabled", "user_verification_failed", "validation", "route_missing"];
 export type ReceiptEmailErrorCode = (typeof RECEIPT_EMAIL_ERROR_CODES)[number];
 export declare function isReceiptEmailErrorCode(value: unknown): value is ReceiptEmailErrorCode;
 /** Der Code eines geworfenen Fehlers, wenn er in [RECEIPT_EMAIL_ERROR_CODES] steht; sonst `undefined`. */

package/dist/esm/models/receipt-email.js

@@ -21,6 +21,8 @@ export const RECEIPT_EMAIL_ERROR_CODES = Object.freeze([
     'account_not_found',
     'admin_required',
     'api_not_approved',
+    'app_check_invalid',
+    'app_check_missing',
     'cashregister_not_assigned',
     'cashregister_not_found',
     'cashregister_token_invalid',

package/dist/esm/models/receipt-errors.d.ts

@@ -16,7 +16,7 @@ import { KasseneckApiError } from '../client/errors.js';
  * ...) stehen in [PAYMENT_ERROR_CODES]. Ein Code ausserhalb bleibt ueber
  * `KasseneckApiError.code` lesbar.
  */
-export declare const RECEIPT_ERROR_CODES: readonly ["cancellation_reference_unavailable", "cashregister_closed", "cashregister_decommissioned", "final_receipt_expired", "final_receipt_not_allowed", "module_inactive", "not_permitted", "receipt_limit_exceeded", "receipt_not_found", "receipt_outcome_unknown", "receipt_type_invalid", "signature_incomplete", "signature_missing", "signing_failed", "small_business_vat_not_allowed", "tip_invalid", "tip_not_allowed", "tip_recipient_unknown", "validation", "account_not_found", "admin_required", "api_not_approved", "cashregister_not_assigned", "cashregister_not_found", "cashregister_token_invalid", "cashregister_token_missing", "dialect_mismatch", "internal_translation_error", "live_not_enabled", "method_not_allowed", "mfa_required", "not_found", "register_user_no_business", "register_user_not_allowed", "register_user_not_found", "response_translation_failed", "session_expired", "session_other_cashregister", "unauthorized", "user_disabled", "user_verification_failed", "route_missing", "response_unreadable"];
+export declare const RECEIPT_ERROR_CODES: readonly ["cancellation_reference_unavailable", "cashregister_closed", "cashregister_decommissioned", "final_receipt_expired", "final_receipt_not_allowed", "module_inactive", "not_permitted", "receipt_limit_exceeded", "receipt_not_found", "receipt_outcome_unknown", "receipt_type_invalid", "signature_incomplete", "signature_missing", "signing_failed", "small_business_vat_not_allowed", "tip_invalid", "tip_not_allowed", "tip_recipient_unknown", "validation", "account_not_found", "admin_required", "api_not_approved", "app_check_invalid", "app_check_missing", "cashregister_not_assigned", "cashregister_not_found", "cashregister_token_invalid", "cashregister_token_missing", "dialect_mismatch", "internal_translation_error", "live_not_enabled", "method_not_allowed", "mfa_required", "not_found", "register_user_no_business", "register_user_not_allowed", "register_user_not_found", "response_translation_failed", "session_expired", "session_other_cashregister", "unauthorized", "user_disabled", "user_verification_failed", "route_missing", "response_unreadable"];
 export type ReceiptErrorCode = (typeof RECEIPT_ERROR_CODES)[number];
 export declare function isReceiptErrorCode(value: unknown): value is ReceiptErrorCode;
 /** Der Code eines geworfenen Fehlers, wenn er in [RECEIPT_ERROR_CODES] steht; sonst `undefined`. */

package/dist/esm/models/receipt-errors.js

@@ -40,6 +40,8 @@ export const RECEIPT_ERROR_CODES = Object.freeze([
     'account_not_found',
     'admin_required',
     'api_not_approved',
+    'app_check_invalid',
+    'app_check_missing',
     'cashregister_not_assigned',
     'cashregister_not_found',
     'cashregister_token_invalid',

package/dist/esm/pos/errors.d.ts

@@ -1,12 +1,13 @@
 import { KasseneckApiError } from '../client/errors.js';
 /**
  * Fehler der Kassen-Aufrufe um den Verkauf herum (Einstellungen, Logo,
- * Artikel, Drucker, Trinkgeld-Empfaenger, Lager) auswerten: am `code`, nie am Text.
+ * Artikel, Drucker, Trinkgeld-Empfaenger, Lager, Inventur zaehlen) auswerten:
+ * am `code`, nie am Text.
  * Belege, Storno und Belegmail haben eigene Listen (`RECEIPT_ERROR_CODES`,
  * `CANCELLATION_ERROR_CODES`, `RECEIPT_EMAIL_ERROR_CODES`), die Anmeldung
  * `REGISTER_ERROR_CODES` im Unterpfad `./register`.
  *
- * Abgeleitet aus dem Vertrags-Export (Fehlerfaelle dieser dreizehn Endpunkte in
+ * Abgeleitet aus dem Vertrags-Export (Fehlerfaelle dieser achtzehn Endpunkte in
  * `fixtures/v3/antworten/kasse.json` und ihre Handler-Codes); ein Test haelt
  * die Liste deckungsgleich. `validation` traegt `data.errors[]` mit dem
  * aeusseren Feldpfad (`business.theme`, `device.shortcuts.splitPayment`).
@@ -19,7 +20,7 @@ import { KasseneckApiError } from '../client/errors.js';
  * ueber `KasseneckApiError.code` lesbar; die Kasse braucht dafuer einen
  * Rueckfallzweig.
  */
-export declare const POS_ERROR_CODES: readonly ["account_not_found", "admin_required", "api_not_approved", "cashregister_not_assigned", "cashregister_not_found", "cashregister_token_invalid", "cashregister_token_missing", "device_not_found", "dialect_mismatch", "internal_translation_error", "live_not_enabled", "location_inactive", "location_not_found", "logo_invalid", "logo_invalid_type", "logo_too_large", "method_not_allowed", "mfa_required", "module_inactive", "not_found", "not_permitted", "print_job_not_found", "print_layout_failed", "printer_not_found", "register_user_no_business", "register_user_not_allowed", "register_user_not_found", "response_translation_failed", "server_error", "session_expired", "session_other_cashregister", "unauthorized", "user_disabled", "user_verification_failed", "validation", "route_missing"];
+export declare const POS_ERROR_CODES: readonly ["account_not_found", "admin_required", "api_not_approved", "app_check_invalid", "app_check_missing", "article_not_found", "article_not_in_scope", "article_not_tracked", "cashregister_not_assigned", "cashregister_not_found", "cashregister_token_invalid", "cashregister_token_missing", "count_already_voided", "count_not_found", "device_not_found", "dialect_mismatch", "idempotency_conflict", "idempotency_key_required", "internal_translation_error", "invalid_cursor", "invalid_quantity", "invalid_serial", "live_not_enabled", "location_inactive", "location_not_found", "logo_invalid", "logo_invalid_type", "logo_too_large", "method_not_allowed", "mfa_required", "module_inactive", "not_found", "not_permitted", "print_job_not_found", "print_layout_failed", "printer_not_found", "register_user_no_business", "register_user_not_allowed", "register_user_not_found", "response_translation_failed", "serial_already_counted", "serial_not_allowed", "serial_required", "server_error", "session_expired", "session_other_cashregister", "stocktake_closed", "stocktake_closing", "stocktake_not_found", "stocktake_not_open", "too_many_counts", "unauthorized", "user_disabled", "user_verification_failed", "validation", "route_missing"];
 export type PosErrorCode = typeof POS_ERROR_CODES[number];
 export declare function isPosErrorCode(value: unknown): value is PosErrorCode;
 /** Der Code eines geworfenen Fehlers, wenn er in [POS_ERROR_CODES] steht; sonst `undefined`. */

package/dist/esm/pos/errors.js

@@ -1,12 +1,13 @@
 import { KasseneckApiError } from '../client/errors.js';
 /**
  * Fehler der Kassen-Aufrufe um den Verkauf herum (Einstellungen, Logo,
- * Artikel, Drucker, Trinkgeld-Empfaenger, Lager) auswerten: am `code`, nie am Text.
+ * Artikel, Drucker, Trinkgeld-Empfaenger, Lager, Inventur zaehlen) auswerten:
+ * am `code`, nie am Text.
  * Belege, Storno und Belegmail haben eigene Listen (`RECEIPT_ERROR_CODES`,
  * `CANCELLATION_ERROR_CODES`, `RECEIPT_EMAIL_ERROR_CODES`), die Anmeldung
  * `REGISTER_ERROR_CODES` im Unterpfad `./register`.
  *
- * Abgeleitet aus dem Vertrags-Export (Fehlerfaelle dieser dreizehn Endpunkte in
+ * Abgeleitet aus dem Vertrags-Export (Fehlerfaelle dieser achtzehn Endpunkte in
  * `fixtures/v3/antworten/kasse.json` und ihre Handler-Codes); ein Test haelt
  * die Liste deckungsgleich. `validation` traegt `data.errors[]` mit dem
  * aeusseren Feldpfad (`business.theme`, `device.shortcuts.splitPayment`).
@@ -23,13 +24,25 @@ export const POS_ERROR_CODES = Object.freeze([
     'account_not_found',
     'admin_required',
     'api_not_approved',
+    'app_check_invalid',
+    'app_check_missing',
+    'article_not_found',
+    'article_not_in_scope',
+    'article_not_tracked',
     'cashregister_not_assigned',
     'cashregister_not_found',
     'cashregister_token_invalid',
     'cashregister_token_missing',
+    'count_already_voided',
+    'count_not_found',
     'device_not_found',
     'dialect_mismatch',
+    'idempotency_conflict',
+    'idempotency_key_required',
     'internal_translation_error',
+    'invalid_cursor',
+    'invalid_quantity',
+    'invalid_serial',
     'live_not_enabled',
     'location_inactive',
     'location_not_found',
@@ -48,9 +61,17 @@ export const POS_ERROR_CODES = Object.freeze([
     'register_user_not_allowed',
     'register_user_not_found',
     'response_translation_failed',
+    'serial_already_counted',
+    'serial_not_allowed',
+    'serial_required',
     'server_error',
     'session_expired',
     'session_other_cashregister',
+    'stocktake_closed',
+    'stocktake_closing',
+    'stocktake_not_found',
+    'stocktake_not_open',
+    'too_many_counts',
     'unauthorized',
     'user_disabled',
     'user_verification_failed',

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

@@ -1,7 +1,7 @@
 /**
  * Kachel-Kasse: Einstellungen, Artikelgruppen/Artikel fuer Kacheln,
  * Rabattverteilung, Drucker, Trinkgeld-Empfaenger, Lager (Standorte, Bestand,
- * Standort der Kasse). Die Aufrufe heissen 1:1 wie
+ * Standort der Kasse), Inventur zaehlen. Die Aufrufe heissen 1:1 wie
  * die Backend-Functions (die Rewrites-Waechter der Web-App leiten daraus ab)
  * und sprechen den Kassenweg `/api/v3` (Schluessel und Werte englisch).
  */
@@ -14,5 +14,8 @@ export { cancelScopeOf, receiptsScopeOf, stockViewOf, type RegisterScope, type R
 export { type NetworkPrinter, type PrintJob, type PrintJobStatus, PRINT_JOB_STATUSES, type PrintJobSource, PRINT_JOB_SOURCES, isPrintJobFinished, type CreatePrintJobOptions, listMyPrinters, createPrintJob, getPrintJob, } from './drucker.js';
 export { listMyTipRecipients } from './trinkgeld.js';
 export { STOCK_LOCATION_TYPES, type StockLocationType, type StockLocation, type StockLocationAddress, type StockLevel, type StockValue, type StockList, type ListMyStockOptions, type SetMyCashregisterStockLocationOptions, type CashregisterStockLocation, listMyStockLocations, listMyStock, setMyCashregisterStockLocation, } from './lager.js';
+export { type ListMyStocktakesOptions, type ListMyStocktakeItemsOptions, type ListMyStocktakeCountsOptions, type RecordMyStocktakeCountOptions, type VoidMyStocktakeCountOptions, listMyStocktakes, listMyStocktakeItems, listMyStocktakeCounts, recordMyStocktakeCount, voidMyStocktakeCount, parseQuantityMilli, } from './inventur.js';
+export type { Stocktake, StocktakeItem, StocktakeCount, StocktakeCountResult, StocktakeItemPage, StocktakeCountPage, StocktakeActor, StocktakeProgress, StocktakeReview, StocktakeRecount, StocktakeScope, } from '../inventory/typen.js';
+export type { StocktakeStatus } from '../inventory/vertrag.js';
 export { RETURN_DISPOSITIONS, isReturnDisposition, type ReturnDisposition } from '../models/cancellation.js';
 export { MESSAGES, ERROR_RULES, ERROR_CODE_RULES, ERROR_OUTCOME_RULES, CALLS_WITH_EFFECT, findErrorRule, messageOutcome, messageText, messageAppliesTo, RECEIPT_EMAIL_ERROR_MESSAGES, receiptEmailErrorMessage, CANCELLATION_PAYMENT_ERROR_MESSAGES, cancellationPaymentErrorMessage, LABELS, labelText, RETURN_DISPOSITION_LABELS, type TextEntry, type MessageKey, type ErrorKind, type ErrorRule, type ErrorRuleDetail, type Surface, type ReceiptEmailMessageCode, type CancellationPaymentMessageCode, type LabelKey, } from './texte.js';

package/dist/esm/pos/index.js

@@ -1,7 +1,7 @@
 /**
  * Kachel-Kasse: Einstellungen, Artikelgruppen/Artikel fuer Kacheln,
  * Rabattverteilung, Drucker, Trinkgeld-Empfaenger, Lager (Standorte, Bestand,
- * Standort der Kasse). Die Aufrufe heissen 1:1 wie
+ * Standort der Kasse), Inventur zaehlen. Die Aufrufe heissen 1:1 wie
  * die Backend-Functions (die Rewrites-Waechter der Web-App leiten daraus ab)
  * und sprechen den Kassenweg `/api/v3` (Schluessel und Werte englisch).
  */
@@ -18,6 +18,7 @@ export { cancelScopeOf, receiptsScopeOf, stockViewOf } from '../register/pairing
 export { PRINT_JOB_STATUSES, PRINT_JOB_SOURCES, isPrintJobFinished, listMyPrinters, createPrintJob, getPrintJob, } from './drucker.js';
 export { listMyTipRecipients } from './trinkgeld.js';
 export { STOCK_LOCATION_TYPES, listMyStockLocations, listMyStock, setMyCashregisterStockLocation, } from './lager.js';
+export { listMyStocktakes, listMyStocktakeItems, listMyStocktakeCounts, recordMyStocktakeCount, voidMyStocktakeCount, parseQuantityMilli, } from './inventur.js';
 // Rueckgabe-Wahl beim Storno (Kassen-Dialog); dieselbe Liste wie an der Wurzel.
 export { RETURN_DISPOSITIONS, isReturnDisposition } from '../models/cancellation.js';
 // Was die Kasse selbst sagt: ein Katalog fuer Browser-Kasse und App.

package/dist/esm/pos/inventur.d.ts

@@ -0,0 +1,104 @@
+import type { InternerTransport } from '../client/aufrufe.js';
+import type { Stocktake, StocktakeCountPage, StocktakeCountResult, StocktakeItemPage } from '../inventory/typen.js';
+import type { StockCondition, StocktakeStatus } from '../inventory/vertrag.js';
+import { type QuantityRule } from './artikel.js';
+/**
+ * Inventur zaehlen an der Kasse (Lager-Kern Stufe 3, Backend
+ * inventur-endpoints.js): offene Inventuren des Standorts, ihre Positionen und
+ * Zaehlungen lesen, zaehlen und eine Zaehlung stornieren. Alle fuenf Aufrufe
+ * gibt es nur ueber den Kassenweg `/api/v3`.
+ *
+ * Rechte am Server: `stocktakeCount` (zaehlen, eigene Zaehlungen stornieren,
+ * lesen) bzw. `stocktakeClose` (auch fremde Zaehlungen stornieren und ab der
+ * Pruefung das Soll sehen). Kassen-Benutzer sehen in [listMyStocktakes] nur
+ * Inventuren in `counting` und solche in `review` mit offenem Nachzaehlen.
+ * Anlegen, Pruefen und Abschliessen gibt es an der Kasse nicht.
+ *
+ * Gezaehlt wird nur online: die Serverzeit ist die Referenzzeit. Bei unklarem
+ * Ausgang (`outcome: 'unknown'`) dieselbe Zaehlung mit **demselben**
+ * `idempotencyKey` erneut senden; sie wirkt genau einmal.
+ *
+ * Die Modelle sind dieselben wie in `./inventory` (`Stocktake`,
+ * `StocktakeItem`, `StocktakeCount`); Mengen in Tausendstel.
+ */
+export interface ListMyStocktakesOptions {
+    /** Nur dieser Standort; `''` gilt wie nicht angegeben. */
+    locationId?: string;
+    /** Nur dieser Stand. */
+    status?: StocktakeStatus;
+}
+export interface ListMyStocktakeItemsOptions {
+    stocktakeId: string;
+    /** Nur ungezaehlte Positionen (in der Pruefung: die zum Nachzaehlen). */
+    openOnly?: boolean;
+    limit?: number;
+    cursor?: string;
+}
+export interface ListMyStocktakeCountsOptions {
+    stocktakeId: string;
+    articleId?: string;
+    /** Nur die eigenen Zaehlungen. */
+    ownOnly?: boolean;
+    limit?: number;
+    cursor?: string;
+}
+export interface RecordMyStocktakeCountOptions {
+    /** Bei „Erneut senden“ derselbe Schluessel wie beim ersten Versuch. */
+    idempotencyKey: string;
+    stocktakeId: string;
+    articleId: string;
+    /** Vorgabe `sellable`. */
+    condition?: StockCondition;
+    /** Tausendstel, aus der Eingabe mit [parseQuantityMilli]; `0` = leer gezaehlt. */
+    quantity: number;
+    /** Einzelstueck: je Stueck genau eine Seriennummer. */
+    serialNumbers?: string[];
+    /** Hoechstens 200 Zeichen. */
+    note?: string | null;
+    /** Ohne Angabe gilt die Kasse der Anmeldung (`registerUserAuth`). */
+    cashregisterId?: string;
+}
+export interface VoidMyStocktakeCountOptions {
+    idempotencyKey: string;
+    stocktakeId: string;
+    countId: string;
+    /** 1–500 Zeichen. */
+    reason: string;
+}
+/** Offene Inventuren (fuer Kassen-Benutzer nur `counting` und `review` mit offenem Nachzaehlen). */
+export declare function listMyStocktakes(transport: InternerTransport, options?: ListMyStocktakesOptions): Promise<Stocktake[]>;
+/** Positionen einer Inventur; ab der Pruefung mit Soll nur mit dem Recht `stocktakeClose`. */
+export declare function listMyStocktakeItems(transport: InternerTransport, options: ListMyStocktakeItemsOptions): Promise<StocktakeItemPage>;
+/** Zaehlungen einer Inventur, neueste zuerst; `ownOnly` nur die eigenen. */
+export declare function listMyStocktakeCounts(transport: InternerTransport, options: ListMyStocktakeCountsOptions): Promise<StocktakeCountPage>;
+/** Eine Zaehlung; Antwort: die Zaehlung und die Position danach (Ist-Summe, kein Soll). */
+export declare function recordMyStocktakeCount(transport: InternerTransport, options: RecordMyStocktakeCountOptions): Promise<StocktakeCountResult>;
+/** Storniert eine Zaehlung mit Grund (fremde nur mit dem Recht `stocktakeClose`). */
+export declare function voidMyStocktakeCount(transport: InternerTransport, options: VoidMyStocktakeCountOptions): Promise<StocktakeCountResult>;
+/**
+ * Eine eingetippte Menge in Tausendstel der Basiseinheit, **ohne Gleitkomma**:
+ * `'12'` → `12000`, `'0,25'` → `250`, `'1.5'` → `1500`.
+ *
+ * - Dezimaltrenner Komma oder Punkt, hoechstens drei Nachkommastellen; weitere
+ *   Nullen am Ende zaehlen nicht (`'1,2340'` → `1234`). `'0'` ist eine gueltige
+ *   Menge (leer gezaehlt).
+ * - **Punkt mit genau drei Ziffern danach und einem Ganzteil ungleich 0**
+ *   (`'1.000'`, `'12.500'`) ist bei jeder Einheit `null`: in oesterreichischer
+ *   Schreibweise ist das ein Tausenderpunkt („tausend“), am Ziffernblock ein
+ *   Dezimalpunkt („eins“); ein Faktor 1000 buchte der Abschluss als Differenz.
+ *   Mit Komma ist es eindeutig (`'1,000'` → `1000`), ebenso `'0.500'`,
+ *   `'1.5'`, `'1.25'`.
+ * - **Stueckware** nur als ganze Zahl ohne Trenner. Stueckware ist, was
+ *   `rule` sagt (die gespeicherte Mengenregel des Artikels,
+ *   `PosArticle.quantityRule`, `'piece'` | `'decimal'`), ohne `rule` die
+ *   Vorgabe der Einheit (`quantityRuleForUnit`: Stk, g, ml …, auch ohne
+ *   Einheit). Einzelstuecke (Seriennummer) sind immer Stueckware: dann
+ *   `'piece'` uebergeben.
+ *
+ * `null` auch fuer: leer, Vorzeichen, Tausenderleerzeichen, Exponent, mehr als
+ * drei Nachkommastellen, groesser als eine sichere Ganzzahl. Die Kasse zeigt
+ * dann ihren Satz (`stocktake.quantity_invalid`), statt still zu runden.
+ * Gemeinsame Prueffaelle mit dem Dart-Zwilling:
+ * `fixtures/stocktake-quantity-cases.json`.
+ */
+export declare function parseQuantityMilli(text: string, unit?: string | null, rule?: QuantityRule | null): number | null;

package/dist/esm/pos/inventur.js

@@ -0,0 +1,109 @@
+import { KasseneckValidationError } from '../client/errors.js';
+import { stornoPruefen, zaehlungPruefen } from '../inventory/inventur.js';
+import { inventur, inventurPosition, inventurZaehlung, liste, naechsterCursor, zaehlungMitPosition } from '../inventory/lesen.js';
+import { anfrage, schluessel } from '../inventory/schreiben.js';
+import { quantityRuleForUnit } from './artikel.js';
+function anfragefehler(name, grund) {
+    return new KasseneckValidationError(name, grund, 'request');
+}
+/** Eine Kennung, die gesendet werden muss. */
+function kennung(name, feld, w) {
+    if (typeof w !== 'string' || w.trim() === '')
+        throw anfragefehler(name, `${feld} fehlt`);
+    return w;
+}
+/** Die Optionen flach, ohne `undefined`; Pflichtkennung `stocktakeId`. */
+function mitInventur(name, options) {
+    const p = anfrage(name, options);
+    kennung(name, 'stocktakeId', p.stocktakeId);
+    return p;
+}
+/** Offene Inventuren (fuer Kassen-Benutzer nur `counting` und `review` mit offenem Nachzaehlen). */
+export async function listMyStocktakes(transport, options = {}) {
+    const name = 'listMyStocktakes';
+    const p = anfrage(name, options);
+    if (p.locationId === '')
+        delete p.locationId;
+    const daten = await transport(name, p);
+    return liste(name, daten, 'stocktakes', inventur);
+}
+/** Positionen einer Inventur; ab der Pruefung mit Soll nur mit dem Recht `stocktakeClose`. */
+export async function listMyStocktakeItems(transport, options) {
+    const name = 'listMyStocktakeItems';
+    const daten = await transport(name, mitInventur(name, options));
+    return { items: liste(name, daten, 'items', inventurPosition), nextCursor: naechsterCursor(name, daten) };
+}
+/** Zaehlungen einer Inventur, neueste zuerst; `ownOnly` nur die eigenen. */
+export async function listMyStocktakeCounts(transport, options) {
+    const name = 'listMyStocktakeCounts';
+    const daten = await transport(name, mitInventur(name, options));
+    return { counts: liste(name, daten, 'counts', inventurZaehlung), nextCursor: naechsterCursor(name, daten) };
+}
+/** Eine Zaehlung; Antwort: die Zaehlung und die Position danach (Ist-Summe, kein Soll). */
+export async function recordMyStocktakeCount(transport, options) {
+    const name = 'recordMyStocktakeCount';
+    const p = mitInventur(name, options);
+    schluessel(name, p, { pflicht: true });
+    zaehlungPruefen(name, p);
+    if (p.cashregisterId !== undefined)
+        kennung(name, 'cashregisterId', p.cashregisterId);
+    return zaehlungMitPosition(name, await transport(name, p));
+}
+/** Storniert eine Zaehlung mit Grund (fremde nur mit dem Recht `stocktakeClose`). */
+export async function voidMyStocktakeCount(transport, options) {
+    const name = 'voidMyStocktakeCount';
+    const p = mitInventur(name, options);
+    schluessel(name, p, { pflicht: true });
+    stornoPruefen(name, p);
+    return zaehlungMitPosition(name, await transport(name, p));
+}
+/** Tausendstel je Einheit: drei Nachkommastellen, wie die Mengen am Draht. */
+const STELLEN = 3;
+/**
+ * Eine eingetippte Menge in Tausendstel der Basiseinheit, **ohne Gleitkomma**:
+ * `'12'` → `12000`, `'0,25'` → `250`, `'1.5'` → `1500`.
+ *
+ * - Dezimaltrenner Komma oder Punkt, hoechstens drei Nachkommastellen; weitere
+ *   Nullen am Ende zaehlen nicht (`'1,2340'` → `1234`). `'0'` ist eine gueltige
+ *   Menge (leer gezaehlt).
+ * - **Punkt mit genau drei Ziffern danach und einem Ganzteil ungleich 0**
+ *   (`'1.000'`, `'12.500'`) ist bei jeder Einheit `null`: in oesterreichischer
+ *   Schreibweise ist das ein Tausenderpunkt („tausend“), am Ziffernblock ein
+ *   Dezimalpunkt („eins“); ein Faktor 1000 buchte der Abschluss als Differenz.
+ *   Mit Komma ist es eindeutig (`'1,000'` → `1000`), ebenso `'0.500'`,
+ *   `'1.5'`, `'1.25'`.
+ * - **Stueckware** nur als ganze Zahl ohne Trenner. Stueckware ist, was
+ *   `rule` sagt (die gespeicherte Mengenregel des Artikels,
+ *   `PosArticle.quantityRule`, `'piece'` | `'decimal'`), ohne `rule` die
+ *   Vorgabe der Einheit (`quantityRuleForUnit`: Stk, g, ml …, auch ohne
+ *   Einheit). Einzelstuecke (Seriennummer) sind immer Stueckware: dann
+ *   `'piece'` uebergeben.
+ *
+ * `null` auch fuer: leer, Vorzeichen, Tausenderleerzeichen, Exponent, mehr als
+ * drei Nachkommastellen, groesser als eine sichere Ganzzahl. Die Kasse zeigt
+ * dann ihren Satz (`stocktake.quantity_invalid`), statt still zu runden.
+ * Gemeinsame Prueffaelle mit dem Dart-Zwilling:
+ * `fixtures/stocktake-quantity-cases.json`.
+ */
+export function parseQuantityMilli(text, unit, rule) {
+    if (typeof text !== 'string')
+        return null;
+    const m = /^(\d*)(?:([.,])(\d*))?$/.exec(text.trim());
+    if (!m)
+        return null;
+    const ganz = m[1] ?? '';
+    const trenner = m[2];
+    const roh = m[3] ?? '';
+    if (ganz === '' && roh === '')
+        return null;
+    const stueck = (rule === 'piece' || rule === 'decimal' ? rule : quantityRuleForUnit(unit).rule) === 'piece';
+    if (trenner !== undefined && stueck)
+        return null;
+    if (trenner === '.' && roh.length === 3 && /[1-9]/.test(ganz))
+        return null;
+    const nachkomma = roh.replace(/0+$/, '');
+    if (nachkomma.length > STELLEN)
+        return null;
+    const milli = BigInt(ganz === '' ? '0' : ganz) * 1000n + BigInt(nachkomma.padEnd(STELLEN, '0'));
+    return milli <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(milli) : null;
+}