@kreiseck/kasseneck-api 1.5.0 → 1.5.1

package/dist/esm/client/aufrufe.js

@@ -237,6 +237,172 @@ export const POS_CALLS = [
     'listMyStock',
     'setMyCashregisterStockLocation',
 ];
+/**
+ * Die Aufrufe **mit Wirkung**, alphabetisch: sie legen etwas an, aendern oder
+ * loeschen es, buchen, signieren, bewegen Geld oder senden etwas hinaus
+ * (Mail, Druckjob, Probesendung). Scheitert einer, nachdem die Anfrage
+ * unterwegs war (Netzfehler, Zeitlimit, HTTP 5xx, unlesbare Erfolgsantwort,
+ * HTML mit Kennzeichen), meldet der Transport `outcome: 'unknown'`: der
+ * Vorgang kann ausgefuehrt sein.
+ *
+ * Bis 1.5.0 galt das nur fuer die sechs signierenden und geldbewegenden
+ * Aufrufe; ein Wareneingang oder eine Rechnung nach einem Zeitlimit kam als
+ * `'rejected'` an, und wer das glaubte und mit NEUEM Idempotenzschluessel
+ * neu sendete, buchte doppelt.
+ *
+ * Geht als `unknownOutcomeCalls` in den Vertrag (`fixtures/surface.json`);
+ * der Dart-Zwilling prueft seine Liste dagegen. Jeder Aufruf aus
+ * [ALL_CALLS], [PUBLIC_CALLS] und [POS_CALLS] steht entweder hier oder in
+ * [CALLS_WITHOUT_EFFECT] (Waechter `test/ausgang-einordnung.test.ts`).
+ */
+export const UNKNOWN_OUTCOME_CALLS = [
+    'activateCashregister',
+    'cancelInvoice',
+    'cancelReceipt',
+    'changeStockCondition',
+    'createArticle',
+    'createCreditNote',
+    'createCustomer',
+    'createCustomerCashregister',
+    'createInvoiceItem',
+    'createPartnerCustomer',
+    'createPartnerWebhook',
+    'createPrintJob',
+    'createReceipt',
+    'createReservation',
+    'createWebhook',
+    'deactivateArticle',
+    'deletePartnerWebhook',
+    'deleteWebhook',
+    'extendReservation',
+    'financeWebService',
+    'hobexPayApi',
+    'hobexRefundApi',
+    'issueInvoice',
+    'pairRegisterDevice',
+    'receiveGoods',
+    'recordInvoicePayment',
+    'recordStockLoss',
+    'releaseReservation',
+    'reportCustomerContract',
+    'requestCustomerSignature',
+    'reverseStockMovement',
+    'revokeCustomerMandate',
+    'rotatePartnerWebhookSecret',
+    'rotateWebhookSecret',
+    'sendPartnerCustomerFonLink',
+    'sendPartnerWebhookTest',
+    'sendReceiptEmail',
+    'sendWebhookTest',
+    'setCustomerMandate',
+    'setMyCashregisterStockLocation',
+    'setMyKasseLogo',
+    'setMyKasseSettings',
+    'setMyRegisterDeviceSettings',
+    'stripeCaptureIntent',
+    'transferStock',
+    'unpairRegisterDevice',
+    'updateArticle',
+    'updateCustomer',
+    'updateInvoiceItem',
+    'updatePartnerWebhook',
+    'updateWebhook',
+    'withdrawInvoiceItem',
+];
+/**
+ * Die Aufrufe **ohne Wirkung**, je mit Grund. Bei ihnen bleibt es bei
+ * `outcome: 'rejected'`, auch nach Zeitlimit, Netzfehler oder HTTP 5xx; eine
+ * Wiederholung bucht nichts doppelt:
+ *
+ * - `read`: reines Lesen (auch Berichte, Dateien, `generateFullReceiptId`,
+ *   das nur einen Link-Schluessel ableitet, und `getCustomerCredentials`,
+ *   dessen Abruf das Backend nur mitschreibt).
+ * - `repeatable`: legt etwas an, das ohne die verlorene Antwort niemand
+ *   erreicht und das von selbst verfaellt, und bucht nichts. Die Sitzung der
+ *   Kassen-Anmeldung (anmelden, verlaengern, abmelden: eine Wiederholung legt
+ *   hoechstens eine weitere kurzlebige Sitzung an bzw. verlaengert oder
+ *   beendet dieselbe noch einmal) und der Stripe-Zahlungslink
+ *   (`createPaymentLinkStripe`: den Link kennt nur die Antwort, ein nie
+ *   zugestellter Link wird nie bezahlt; Geld bewegt erst die Zahlung bzw.
+ *   `stripeCaptureIntent`).
+ *
+ * Probelaeufe (`previewGoodsReceipt`, `previewInvoice`) teilen den Namen mit
+ * dem echten Aufruf und stehen darum nicht hier; die Huellen setzen fuer sie
+ * `hasEffect: false` beim Aufruf, das nur zusammen mit `dryRun: true` gilt
+ * (siehe `TransportCallOptions`).
+ *
+ * Paketintern; nicht Teil der Paketoberflaeche.
+ */
+export const CALLS_WITHOUT_EFFECT = Object.freeze({
+    checkPartnerCustomerEmail: 'read',
+    downloadDailyReport: 'read',
+    downloadReceipt: 'read',
+    downloadReport: 'read',
+    createPaymentLinkStripe: 'repeatable',
+    endRegisterSession: 'repeatable',
+    generateFullReceiptId: 'read',
+    getArticle: 'read',
+    getCustomer: 'read',
+    getCustomerCredentials: 'read',
+    getCustomerSignatureStatus: 'read',
+    getFirstReceiptDate: 'read',
+    getInvoice: 'read',
+    getInvoiceItem: 'read',
+    getInvoicePdf: 'read',
+    getInvoiceSetupStatus: 'read',
+    getInvoiceXml: 'read',
+    getKasseSettings: 'read',
+    getPartnerBilling: 'read',
+    getPartnerBillingMonth: 'read',
+    getPartnerCustomer: 'read',
+    getPartnerInfo: 'read',
+    getPrintJob: 'read',
+    getReceipt: 'read',
+    getReportV2: 'read',
+    getReservation: 'read',
+    getStock: 'read',
+    hobexGetStatus: 'read',
+    listArticles: 'read',
+    listBrands: 'read',
+    listCustomerCashregisters: 'read',
+    listInvoiceItems: 'read',
+    listInvoices: 'read',
+    listLocations: 'read',
+    listMyArticleGroups: 'read',
+    listMyArticles: 'read',
+    listMyCashregisters: 'read',
+    listMyPrinters: 'read',
+    listMyReceipts: 'read',
+    listMyStock: 'read',
+    listMyStockLocations: 'read',
+    listMyTipRecipients: 'read',
+    listPartnerCustomers: 'read',
+    listPartnerWebhookDeliveries: 'read',
+    listPartnerWebhooks: 'read',
+    listRegisterSessionsForDevice: 'read',
+    listRegisterUsersForDevice: 'read',
+    listReservations: 'read',
+    listStock: 'read',
+    listStockMovements: 'read',
+    listWebhookDeliveries: 'read',
+    listWebhooks: 'read',
+    lookupArticleByCode: 'read',
+    registerPinLogin: 'repeatable',
+    registerUserLogin: 'repeatable',
+    renewRegisterSession: 'repeatable',
+    searchCustomers: 'read',
+});
+const MIT_WIRKUNG = new Set(UNKNOWN_OUTCOME_CALLS);
+/**
+ * Hat dieser Aufruf Wirkung, ist sein Ausgang nach Zeitlimit, Netzfehler,
+ * HTTP 5xx oder unlesbarer Erfolgsantwort also unklar? `financeWebService`
+ * zaehlt mit jedem Vorgang. Ein Name, den dieses Paket nicht kennt (der
+ * offene Transport nimmt jeden), ist `false`; wer so einen Aufruf mit Wirkung
+ * absetzt, sagt es mit `hasEffect: true`.
+ */
+export function isUnknownOutcomeCall(name) {
+    return MIT_WIRKUNG.has(name);
+}
 const OEFFENTLICH = new Set(PUBLIC_CALLS);
 const KASSENWEG = new Set(POS_CALLS);
 const NUR_KASSE = new Set(POS_CALLS.filter((name) => !OEFFENTLICH.has(name)));

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

@@ -25,20 +25,27 @@
  *   **Entscheidend ist `outcome`:** `'rejected'` heisst abgelehnt, nichts
  *   geschehen, Wiederholen hilft nicht. `'unknown'` heisst: der Vorgang kann
  *   ausgefuehrt sein (bei `createReceipt` ein signierter Beleg). Dann **nie
- *   wiederholen**, sondern das Ergebnis nachlesen (Belegliste, `getReceipt`).
+ *   blind wiederholen**: Belege, Stornos und Zahlungen nachlesen
+ *   (Belegliste, `getReceipt`, Terminal-Beleg); ein Aufruf mit
+ *   `idempotencyKey` (Lager schreiben, Rechnung, Partner-Betrieb mit
+ *   Schluessel) darf mit **demselben** Schluessel erneut gesendet werden und
+ *   wirkt genau einmal, nie mit einem neuen. `createInvoiceItem` erkennt die
+ *   Wiederholung an `source` + `reference` (dieselben Werte erneut senden);
+ *   Posten aendern oder zurueckziehen und Mandate haben keinen Schluessel:
+ *   erst nachlesen.
  * - `KasseneckHttpError` — die Antwort war **keine** verwertbare Huelle:
  *   HTTP 500/404 ohne Huelle, leerer Rumpf oder Text statt JSON. Beim
  *   Bericht-Download gelten dieselben Gruende fuer alles, was kein PDF ist.
  *   `reason` trennt die Faelle maschinenlesbar. Auf einem Aufruf mit
- *   Wirkung (signierend oder geldbewegend) hat HTTP 5xx
+ *   Wirkung (`UNKNOWN_OUTCOME_CALLS` in aufrufe.ts) hat HTTP 5xx
  *   `outcome: 'unknown'`, ebenso HTTP 200 mit Kennzeichen, aber leerem oder
  *   unlesbarem Rumpf.
  * - `KasseneckNetworkError` — die Antwort kam gar nicht: Netz weg, DNS,
  *   abgebrochene Verbindung oder Zeitueberschreitung (`timedOut`). Auch hier
  *   gilt `outcome`: war die Anfrage schon unterwegs und ist der Aufruf einer
- *   mit Wirkung (signierend: `createReceipt`, `cancelReceipt`,
- *   `financeWebService`; geldbewegend: `hobexPayApi`, `hobexRefundApi`,
- *   `stripeCaptureIntent`), ist er `'unknown'`.
+ *   mit Wirkung (signieren, Geld bewegen, buchen, ausstellen, anlegen,
+ *   aendern, loeschen, senden; die Liste `UNKNOWN_OUTCOME_CALLS`), ist er
+ *   `'unknown'`. Lesen und Probelauf bleiben `'rejected'`.
  * - `KasseneckAuthError` — es kam nicht einmal zur Anfrage, weil die Anmeldung
  *   scheiterte (fehlende Zugangsdaten, oder der Token-/Sitzungsgeber warf).
  *   In der Browser-Kasse mit ihrer 90-Sekunden-Sitzung ist das Alltag, kein
@@ -106,8 +113,10 @@ export declare function causeDigest(ursache: unknown, geheimnisse: readonly stri
 export declare function fehlerDetails(daten: unknown, geheimnisse: readonly string[]): Record<string, unknown>;
 /**
  * Ausgang eines gescheiterten Aufrufs. `'rejected'`: nichts geschehen.
- * `'unknown'`: der Vorgang kann ausgefuehrt sein; nie wiederholen, sondern
- * das Ergebnis nachlesen.
+ * `'unknown'`: der Vorgang kann ausgefuehrt sein; nie blind wiederholen.
+ * Belege, Stornos und Zahlungen nachlesen; ein Aufruf mit `idempotencyKey`
+ * nur mit **demselben** Schluessel erneut senden (wirkt genau einmal); ohne
+ * Schluessel erst nachlesen.
  */
 export type ErrorOutcome = 'unknown' | 'rejected';
 /**
@@ -195,12 +204,12 @@ export declare class KasseneckHttpError extends Error {
     /** Maschinenlesbarer Grund — trennt den Rewrite-Fall vom 500er ohne Textparsen. */
     readonly reason: HttpFailureReason;
     /**
-     * `'unknown'` auf einem Aufruf mit Wirkung (`createReceipt`,
-     * `cancelReceipt`, `financeWebService`, `hobexPayApi`, `hobexRefundApi`,
-     * `stripeCaptureIntent`) bei HTTP 5xx und bei HTTP 200 mit
-     * Kennzeichen, aber unlesbarem Rumpf (`empty-body`, `not-json` auch bei
-     * `text/html`, `missing-status`): der Handler kann gelaufen sein, nie wiederholen,
-     * sondern nachlesen. Sonst `'rejected'` (auch 4xx).
+     * `'unknown'` auf einem Aufruf mit Wirkung (`UNKNOWN_OUTCOME_CALLS`:
+     * signieren, Geld bewegen, buchen, ausstellen, anlegen, aendern, loeschen,
+     * senden) bei HTTP 5xx und bei HTTP 200 mit Kennzeichen, aber unlesbarem
+     * Rumpf (`empty-body`, `not-json` auch bei `text/html`, `missing-status`):
+     * der Handler kann gelaufen sein, nie blind wiederholen (siehe
+     * [ErrorOutcome]). Sonst `'rejected'` (auch 4xx, Lesen und Probelauf).
      */
     readonly outcome: ErrorOutcome;
     constructor(functionName: string, statusCode: number, contentType: string | undefined, reason: HttpFailureReason, outcome?: ErrorOutcome);
@@ -218,9 +227,10 @@ export declare class KasseneckNetworkError extends Error {
     /** Code der zugrunde liegenden Ursache, sofern unbedenklich (z. B. `ECONNREFUSED`). */
     readonly causeCode: string | undefined;
     /**
-     * `'unknown'`, wenn die Anfrage schon unterwegs war und der Aufruf signiert
-     * (`createReceipt`, `cancelReceipt`, `financeWebService`): dann nie
-     * wiederholen, sondern nachlesen. Sonst `'rejected'`.
+     * `'unknown'`, wenn die Anfrage schon unterwegs war und der Aufruf Wirkung
+     * hat (`UNKNOWN_OUTCOME_CALLS`): dann nie blind wiederholen (siehe
+     * [ErrorOutcome]). Sonst `'rejected'`, auch bei Lesen und Probelauf und
+     * wenn schon die Anmeldung das Zeitlimit verbrauchte.
      */
     readonly outcome: ErrorOutcome;
     constructor(functionName: string, timedOut: boolean, timeoutMs: number, cause?: CauseDigest, outcome?: ErrorOutcome);
@@ -273,9 +283,12 @@ export declare class KasseneckValidationError extends Error {
 export type KasseneckError = KasseneckApiError | KasseneckHttpError | KasseneckNetworkError | KasseneckAuthError | KasseneckValidationError;
 /**
  * Ist der Ausgang dieses Fehlers unklar (`outcome === 'unknown'`)? Dann den
- * Aufruf **nicht wiederholen**, sondern das Ergebnis nachlesen. Gilt fuer
- * jede Fehlerart; nur [KasseneckApiError], [KasseneckHttpError] und
- * [KasseneckNetworkError] koennen `'unknown'` sein.
+ * Aufruf **nicht blind wiederholen**: Belege, Stornos und Zahlungen
+ * nachlesen; einen Aufruf mit `idempotencyKey` nur mit **demselben**
+ * Schluessel erneut senden (wirkt genau einmal, ein neuer buchte doppelt);
+ * ohne Schluessel erst nachlesen. Gilt fuer jede Fehlerart; nur
+ * [KasseneckApiError], [KasseneckHttpError] und [KasseneckNetworkError]
+ * koennen `'unknown'` sein.
  */
 export declare function isOutcomeUnknown(error: unknown): boolean;
 export declare function isKasseneckApiError(error: unknown): error is KasseneckApiError;

package/dist/esm/client/errors.js

@@ -25,20 +25,27 @@
  *   **Entscheidend ist `outcome`:** `'rejected'` heisst abgelehnt, nichts
  *   geschehen, Wiederholen hilft nicht. `'unknown'` heisst: der Vorgang kann
  *   ausgefuehrt sein (bei `createReceipt` ein signierter Beleg). Dann **nie
- *   wiederholen**, sondern das Ergebnis nachlesen (Belegliste, `getReceipt`).
+ *   blind wiederholen**: Belege, Stornos und Zahlungen nachlesen
+ *   (Belegliste, `getReceipt`, Terminal-Beleg); ein Aufruf mit
+ *   `idempotencyKey` (Lager schreiben, Rechnung, Partner-Betrieb mit
+ *   Schluessel) darf mit **demselben** Schluessel erneut gesendet werden und
+ *   wirkt genau einmal, nie mit einem neuen. `createInvoiceItem` erkennt die
+ *   Wiederholung an `source` + `reference` (dieselben Werte erneut senden);
+ *   Posten aendern oder zurueckziehen und Mandate haben keinen Schluessel:
+ *   erst nachlesen.
  * - `KasseneckHttpError` — die Antwort war **keine** verwertbare Huelle:
  *   HTTP 500/404 ohne Huelle, leerer Rumpf oder Text statt JSON. Beim
  *   Bericht-Download gelten dieselben Gruende fuer alles, was kein PDF ist.
  *   `reason` trennt die Faelle maschinenlesbar. Auf einem Aufruf mit
- *   Wirkung (signierend oder geldbewegend) hat HTTP 5xx
+ *   Wirkung (`UNKNOWN_OUTCOME_CALLS` in aufrufe.ts) hat HTTP 5xx
  *   `outcome: 'unknown'`, ebenso HTTP 200 mit Kennzeichen, aber leerem oder
  *   unlesbarem Rumpf.
  * - `KasseneckNetworkError` — die Antwort kam gar nicht: Netz weg, DNS,
  *   abgebrochene Verbindung oder Zeitueberschreitung (`timedOut`). Auch hier
  *   gilt `outcome`: war die Anfrage schon unterwegs und ist der Aufruf einer
- *   mit Wirkung (signierend: `createReceipt`, `cancelReceipt`,
- *   `financeWebService`; geldbewegend: `hobexPayApi`, `hobexRefundApi`,
- *   `stripeCaptureIntent`), ist er `'unknown'`.
+ *   mit Wirkung (signieren, Geld bewegen, buchen, ausstellen, anlegen,
+ *   aendern, loeschen, senden; die Liste `UNKNOWN_OUTCOME_CALLS`), ist er
+ *   `'unknown'`. Lesen und Probelauf bleiben `'rejected'`.
  * - `KasseneckAuthError` — es kam nicht einmal zur Anfrage, weil die Anmeldung
  *   scheiterte (fehlende Zugangsdaten, oder der Token-/Sitzungsgeber warf).
  *   In der Browser-Kasse mit ihrer 90-Sekunden-Sitzung ist das Alltag, kein
@@ -365,12 +372,12 @@ export class KasseneckHttpError extends Error {
     /** Maschinenlesbarer Grund — trennt den Rewrite-Fall vom 500er ohne Textparsen. */
     reason;
     /**
-     * `'unknown'` auf einem Aufruf mit Wirkung (`createReceipt`,
-     * `cancelReceipt`, `financeWebService`, `hobexPayApi`, `hobexRefundApi`,
-     * `stripeCaptureIntent`) bei HTTP 5xx und bei HTTP 200 mit
-     * Kennzeichen, aber unlesbarem Rumpf (`empty-body`, `not-json` auch bei
-     * `text/html`, `missing-status`): der Handler kann gelaufen sein, nie wiederholen,
-     * sondern nachlesen. Sonst `'rejected'` (auch 4xx).
+     * `'unknown'` auf einem Aufruf mit Wirkung (`UNKNOWN_OUTCOME_CALLS`:
+     * signieren, Geld bewegen, buchen, ausstellen, anlegen, aendern, loeschen,
+     * senden) bei HTTP 5xx und bei HTTP 200 mit Kennzeichen, aber unlesbarem
+     * Rumpf (`empty-body`, `not-json` auch bei `text/html`, `missing-status`):
+     * der Handler kann gelaufen sein, nie blind wiederholen (siehe
+     * [ErrorOutcome]). Sonst `'rejected'` (auch 4xx, Lesen und Probelauf).
      */
     outcome;
     constructor(functionName, statusCode, contentType, reason, outcome = 'rejected') {
@@ -396,9 +403,10 @@ export class KasseneckNetworkError extends Error {
     /** Code der zugrunde liegenden Ursache, sofern unbedenklich (z. B. `ECONNREFUSED`). */
     causeCode;
     /**
-     * `'unknown'`, wenn die Anfrage schon unterwegs war und der Aufruf signiert
-     * (`createReceipt`, `cancelReceipt`, `financeWebService`): dann nie
-     * wiederholen, sondern nachlesen. Sonst `'rejected'`.
+     * `'unknown'`, wenn die Anfrage schon unterwegs war und der Aufruf Wirkung
+     * hat (`UNKNOWN_OUTCOME_CALLS`): dann nie blind wiederholen (siehe
+     * [ErrorOutcome]). Sonst `'rejected'`, auch bei Lesen und Probelauf und
+     * wenn schon die Anmeldung das Zeitlimit verbrauchte.
      */
     outcome;
     constructor(functionName, timedOut, timeoutMs, cause = {}, outcome = 'rejected') {
@@ -464,9 +472,12 @@ export class KasseneckValidationError extends Error {
 }
 /**
  * Ist der Ausgang dieses Fehlers unklar (`outcome === 'unknown'`)? Dann den
- * Aufruf **nicht wiederholen**, sondern das Ergebnis nachlesen. Gilt fuer
- * jede Fehlerart; nur [KasseneckApiError], [KasseneckHttpError] und
- * [KasseneckNetworkError] koennen `'unknown'` sein.
+ * Aufruf **nicht blind wiederholen**: Belege, Stornos und Zahlungen
+ * nachlesen; einen Aufruf mit `idempotencyKey` nur mit **demselben**
+ * Schluessel erneut senden (wirkt genau einmal, ein neuer buchte doppelt);
+ * ohne Schluessel erst nachlesen. Gilt fuer jede Fehlerart; nur
+ * [KasseneckApiError], [KasseneckHttpError] und [KasseneckNetworkError]
+ * koennen `'unknown'` sein.
  */
 export function isOutcomeUnknown(error) {
     return ((error instanceof KasseneckApiError || error instanceof KasseneckHttpError || error instanceof KasseneckNetworkError)

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

@@ -1,6 +1,6 @@
 export { type AuthCredentials, type KasseneckAuth, type ApiKeyAuthOptions, type RegisterUserAuthOptions, apiKeyAuth, registerUserAuth, } from './auth.js';
-export { DEFAULT_BASE_URL, POS_BASE_URL, DEFAULT_TIMEOUT_MS, type HttpResponseLike, type HttpRequestInit, type FetchLike, type TransportOptions, type TransportBodyFields, type KasseneckTransport, type KasseneckBinaryTransport, createTransport, createBinaryTransport, } from './transport.js';
-export { ALL_CALLS, type ApiCall, PUBLIC_CALLS, POS_CALLS, type PublicCall, type PosCall, } from './aufrufe.js';
+export { DEFAULT_BASE_URL, POS_BASE_URL, DEFAULT_TIMEOUT_MS, type HttpResponseLike, type HttpRequestInit, type FetchLike, type TransportOptions, type TransportBodyFields, type TransportCallOptions, type KasseneckTransport, type KasseneckBinaryTransport, createTransport, createBinaryTransport, } from './transport.js';
+export { ALL_CALLS, type ApiCall, PUBLIC_CALLS, POS_CALLS, UNKNOWN_OUTCOME_CALLS, type PublicCall, type PosCall, } from './aufrufe.js';
 export { KasseneckApiError, KasseneckAuthError, KasseneckHttpError, KasseneckNetworkError, KasseneckValidationError, type ValidationScope, type KasseneckError, type HttpFailureReason, type CauseDigest, type ErrorOutcome, CLIENT_ERROR_CODES, type ClientErrorCode, isKasseneckApiError, isKasseneckAuthError, isKasseneckHttpError, isKasseneckNetworkError, isKasseneckValidationError, isOutcomeUnknown, } from './errors.js';
 export { type ReceiptCommonOptions, type SellReceiptOptions, type TipOptions, type TipRecipientShare, type CancelReceiptOptions, type ReceiptWithCompany, sellReceipt, sellReceiptWithCompany, paymentsExpectedCents, cardRefundReference, receiptLayoutFromResult, cancelReceipt, type CancelReceiptResult, zeroReceipt, getReceipt, getReceiptWithCompany, generateFullReceiptId, getFirstReceiptDate, listMyReceipts, type ListMyReceiptsOptions, type ReceiptList, type ReceiptListStats, checkVoucherCombinationError, type SendReceiptEmailOptions, type SendReceiptEmailResult, sendReceiptEmail, } from './receipts.js';
 export { listMyCashregisters } from './cashregisters.js';

package/dist/esm/client/index.js

@@ -1,6 +1,6 @@
 export { apiKeyAuth, registerUserAuth, } from './auth.js';
 export { DEFAULT_BASE_URL, POS_BASE_URL, DEFAULT_TIMEOUT_MS, createTransport, createBinaryTransport, } from './transport.js';
-export { ALL_CALLS, PUBLIC_CALLS, POS_CALLS, } from './aufrufe.js';
+export { ALL_CALLS, PUBLIC_CALLS, POS_CALLS, UNKNOWN_OUTCOME_CALLS, } from './aufrufe.js';
 export { KasseneckApiError, KasseneckAuthError, KasseneckHttpError, KasseneckNetworkError, KasseneckValidationError, CLIENT_ERROR_CODES, isKasseneckApiError, isKasseneckAuthError, isKasseneckHttpError, isKasseneckNetworkError, isKasseneckValidationError, isOutcomeUnknown, } from './errors.js';
 export { sellReceipt, sellReceiptWithCompany, paymentsExpectedCents, cardRefundReference, receiptLayoutFromResult, cancelReceipt, zeroReceipt, getReceipt, getReceiptWithCompany, generateFullReceiptId, getFirstReceiptDate, listMyReceipts, checkVoucherCombinationError, sendReceiptEmail, } from './receipts.js';
 export { listMyCashregisters } from './cashregisters.js';

package/dist/esm/client/transport.d.ts

@@ -33,6 +33,12 @@ import { type KasseneckAuth } from './auth.js';
  * **Kein Wiederholen fehlgeschlagener Aufrufe.** Ein Beleg ist nicht folgenlos
  * wiederholbar; ohne entschiedene Idempotenz waere ein automatischer zweiter
  * Versuch ein zweiter Beleg.
+ *
+ * **Ausgang je Aufruf.** Ob ein Scheitern nach dem Senden `outcome: 'unknown'`
+ * traegt, haengt am Aufruf: mit Wirkung ([UNKNOWN_OUTCOME_CALLS] in
+ * aufrufe.ts) ja, Lesen und Probelauf nein. Ein Probelauf traegt denselben
+ * Namen wie der echte Aufruf; die Huelle sagt es darum beim Aufruf
+ * (`hasEffect: false`, [TransportCallOptions]).
  */
 /** Basis-URL der oeffentlichen API (Produktion). */
 export declare const DEFAULT_BASE_URL = "https://api.kasseneck.at/v3";
@@ -151,7 +157,27 @@ export interface TransportBodyFields {
     /** Vorgangsart von `financeWebService` (z. B. `status_cashbox`). */
     method?: string;
 }
-export type KasseneckTransport = <T = unknown>(functionName: string, params?: Record<string, unknown>, extraBodyFields?: TransportBodyFields, secretParams?: readonly string[]) => Promise<T>;
+/**
+ * Einstellungen fuer **einen** Aufruf, die nicht mitgesendet werden.
+ */
+export interface TransportCallOptions {
+    /**
+     * Hat dieser Aufruf Wirkung? Entscheidet den Ausgang, wenn er scheitert,
+     * nachdem die Anfrage unterwegs war (Netzfehler, Zeitlimit, HTTP 5xx,
+     * unlesbare Erfolgsantwort, HTML mit Kennzeichen): `true` ergibt
+     * `outcome: 'unknown'`. Ohne Angabe gilt die Liste des Pakets
+     * (`UNKNOWN_OUTCOME_CALLS`); ein Name, den sie nicht kennt, gilt dann als
+     * ohne Wirkung.
+     *
+     * `true` fuer einen Aufruf mit Wirkung, den dieses Paket nicht kennt.
+     * `false` gilt **nur zusammen mit `params.dryRun === true`** (Probelauf
+     * unter dem Namen des echten Aufrufs, schreibt nichts) und ergibt dann
+     * `'rejected'`; ohne `dryRun: true` bleibt ein Aufruf aus der Liste
+     * `'unknown'`, was immer hier steht.
+     */
+    hasEffect?: boolean;
+}
+export type KasseneckTransport = <T = unknown>(functionName: string, params?: Record<string, unknown>, extraBodyFields?: TransportBodyFields, secretParams?: readonly string[], options?: TransportCallOptions) => Promise<T>;
 /**
  * Ruft eine Backend-Funktion auf, die **Binaerdaten** liefert (die beiden
  * Bericht-PDFs), und gibt sie als `Uint8Array` zurueck.

package/dist/esm/client/transport.js

@@ -1,5 +1,5 @@
 import { isRegisterUserAuth } from './auth.js';
-import { isPosCall, isPosOnlyCall } from './aufrufe.js';
+import { isPosCall, isPosOnlyCall, isUnknownOutcomeCall } from './aufrufe.js';
 import { PACKAGE_VERSION } from '../version.js';
 import { KasseneckApiError, KasseneckAuthError, KasseneckHttpError, KasseneckNetworkError, KasseneckValidationError, causeDigest, fehlerDetails, } from './errors.js';
 /**
@@ -36,6 +36,12 @@ import { KasseneckApiError, KasseneckAuthError, KasseneckHttpError, KasseneckNet
  * **Kein Wiederholen fehlgeschlagener Aufrufe.** Ein Beleg ist nicht folgenlos
  * wiederholbar; ohne entschiedene Idempotenz waere ein automatischer zweiter
  * Versuch ein zweiter Beleg.
+ *
+ * **Ausgang je Aufruf.** Ob ein Scheitern nach dem Senden `outcome: 'unknown'`
+ * traegt, haengt am Aufruf: mit Wirkung ([UNKNOWN_OUTCOME_CALLS] in
+ * aufrufe.ts) ja, Lesen und Probelauf nein. Ein Probelauf traegt denselben
+ * Namen wie der echte Aufruf; die Huelle sagt es darum beim Aufruf
+ * (`hasEffect: false`, [TransportCallOptions]).
  */
 /** Basis-URL der oeffentlichen API (Produktion). */
 export const DEFAULT_BASE_URL = 'https://api.kasseneck.at/v3';
@@ -56,23 +62,6 @@ const VERSION_WERT = 'v3';
 const KASSENECK_HOSTS = new Set(['api.kasseneck.at', 'kasse.kasseneck.at']);
 /** Die 1.x-Linie spricht nur `/v3`: jede Basis endet so (`/v3` oder `/api/v3`). */
 const V3_ENDE = /\/v3$/;
-/**
- * Aufrufe mit Wirkung, die nie blind wiederholt werden duerfen: sie signieren
- * (`createReceipt`, `cancelReceipt`), loesen bei FinanzOnline etwas aus
- * (`financeWebService`) oder bewegen Geld (`hobexPayApi` belastet eine Karte,
- * `hobexRefundApi` erstattet, `stripeCaptureIntent` zieht eine vorgemerkte
- * Zahlung ein). Scheitert einer, nachdem die Anfrage unterwegs war (Netz,
- * Zeitlimit, HTTP 5xx, unlesbare Erfolgsantwort, HTML mit Kennzeichen), ist
- * sein Ausgang offen.
- */
-const UNKNOWN_OUTCOME_CALLS = new Set([
-    'createReceipt',
-    'cancelReceipt',
-    'financeWebService',
-    'hobexPayApi',
-    'hobexRefundApi',
-    'stripeCaptureIntent',
-]);
 /**
  * Produkte, die das Backend in `Kasseneck-Client` zaehlt (Positivliste,
  * Nachtrag §6); alles andere zaehlte dort als `ungueltig`. Das Paket weist
@@ -89,7 +78,7 @@ const CLIENT_MAX = 64;
 export const DEFAULT_TIMEOUT_MS = 30_000;
 export function createTransport(options) {
     const kern = createCore(options);
-    return (functionName, params, extraBodyFields, secretParams) => kern(functionName, params, extraBodyFields, secretParams, alsText, jsonAuswerten);
+    return (functionName, params, extraBodyFields, secretParams, callOptions) => kern(functionName, params, extraBodyFields, secretParams, callOptions, alsText, jsonAuswerten);
 }
 /**
  * Zweiter Einstiegspunkt fuer die Bericht-Downloads. Er liest die Antwort als
@@ -101,7 +90,7 @@ export function createTransport(options) {
  */
 export function createBinaryTransport(options) {
     const kern = createCore(options);
-    return (functionName, params) => kern(functionName, params, undefined, undefined, alsBytes, pdfAuswerten);
+    return (functionName, params) => kern(functionName, params, undefined, undefined, undefined, alsBytes, pdfAuswerten);
 }
 /**
  * Gemeinsamer Kern beider Einstiegspunkte: Anmeldung, Zeitlimit, Anfrage und
@@ -125,12 +114,21 @@ function createCore(options) {
      * (Berichte, Zahlungen, FinanzOnline), geht an die oeffentliche Basis.
      */
     const basisFuer = (functionName) => isPosOnlyCall(functionName) || (kassenweg && isPosCall(functionName)) ? kassenBasis : oeffentlicheBasis;
-    return async function aufrufen(functionName, params = {}, extraBodyFields, secretParams, lesen, auswerten) {
+    return async function aufrufen(functionName, params = {}, extraBodyFields, secretParams, callOptions, lesen, auswerten) {
         // Die URL nennt die Backend-Funktion, die Fehler nennen den **Vorgang**:
         // `financeWebService` fuehrt ein Dutzend verschiedener Vorgaenge unter einem
         // Endpunkt, und ein Fehler, der nur "financeWebService" sagt, verschweigt
         // dem Aufrufer, welcher davon scheiterte.
         const fehlerName = extraBodyFields?.method ? `${functionName}/${extraBodyFields.method}` : functionName;
+        // Ausgang eines Scheiterns nach dem Senden: offen, wenn der Aufruf Wirkung
+        // hat. `hasEffect: true` hebt einen fremden Aufruf auf `unknown`.
+        // `hasEffect: false` senkt einen Aufruf mit Wirkung nur, wenn er wirklich
+        // ein Probelauf ist (`dryRun === true`, so streng prueft auch das
+        // Backend): sonst liefe ein echter Beleg oder eine Buchung nach einem
+        // Zeitlimit als `rejected`, und genau das fuehrt zur Doppelbuchung.
+        const probelauf = callOptions?.hasEffect === false && params['dryRun'] === true;
+        const wirkung = callOptions?.hasEffect === true || (isUnknownOutcomeCall(functionName) && !probelauf);
+        const nachDemSenden = wirkung ? 'unknown' : 'rejected';
         // Das Zeitlimit laeuft ab HIER — es deckt die Anmeldung mit ab. Haengt die
         // Token-Erneuerung auf flauem Netz, haette der Aufruf sonst weder Ergebnis
         // noch Fehler, und die Kasse stuende still.
@@ -170,8 +168,9 @@ function createCore(options) {
                 }
                 // Bis hierher kam keine verwertbare Antwort: Netz weg oder Zeitlimit.
                 // Die Anfrage war schon unterwegs: bei einem Aufruf mit Wirkung kann
-                // der Beleg bzw. die Zahlung entstanden sein (Ausgang unklar, nachlesen).
-                return new KasseneckNetworkError(fehlerName, abbruch.signal.aborted, zeitlimitMs, causeDigest(ursache, geheimnisse), UNKNOWN_OUTCOME_CALLS.has(functionName) ? 'unknown' : 'rejected');
+                // der Vorgang ausgefuehrt sein (Beleg, Zahlung, Buchung, Rechnung;
+                // Ausgang unklar).
+                return new KasseneckNetworkError(fehlerName, abbruch.signal.aborted, zeitlimitMs, causeDigest(ursache, geheimnisse), nachDemSenden);
             };
             const basis = basisFuer(functionName);
             const url = `${basis}/${encodeURIComponent(functionName)}`;
@@ -225,7 +224,7 @@ function createCore(options) {
                         throw fehler;
                 }
                 // 5xx auf einem Aufruf mit Wirkung: der Handler kann gelaufen sein.
-                const ausgang = antwort.status >= 500 && UNKNOWN_OUTCOME_CALLS.has(functionName) ? 'unknown' : 'rejected';
+                const ausgang = antwort.status >= 500 ? nachDemSenden : 'rejected';
                 throw new KasseneckHttpError(fehlerName, antwort.status, inhaltstyp, 'server-error', ausgang);
             }
             // HTTP 200 mit HTML: die Auffangregel der Single-Page-App hat den Aufruf
@@ -233,9 +232,9 @@ function createCore(options) {
             if (inhaltstyp !== undefined && /^\s*text\/html\b/i.test(inhaltstyp)) {
                 // Mit Kennzeichen hat der `/v3`-Rand den Aufruf gesehen (etwa ein
                 // Proxy, der nur den Inhaltstyp umschreibt). Bei einem Aufruf mit
-                // Wirkung kann der Beleg bzw. die Zahlung dann entstanden sein: unlesbarer Rumpf,
+                // Wirkung kann der Vorgang dann ausgefuehrt sein: unlesbarer Rumpf,
                 // Ausgang unklar, statt `route_missing`.
-                if (UNKNOWN_OUTCOME_CALLS.has(functionName) && traegtKennzeichen(antwort)) {
+                if (nachDemSenden === 'unknown' && traegtKennzeichen(antwort)) {
                     throw new KasseneckHttpError(fehlerName, antwort.status, inhaltstyp, 'not-json', 'unknown');
                 }
                 throw new KasseneckApiError(fehlerName, 'Route fehlt: die Antwort ist eine HTML-Seite statt des Backends', {}, 'route_missing');
@@ -253,8 +252,7 @@ function createCore(options) {
             // Ab hier kam HTTP 200 mit Kennzeichen: der `/v3`-Rand hat den Aufruf
             // gesehen. Ist der Rumpf dann unlesbar (gekuerzt von einem Proxy,
             // abgebrochene Verbindung), kann ein Handler mit Wirkung gelaufen sein.
-            const unlesbar = UNKNOWN_OUTCOME_CALLS.has(functionName) ? 'unknown' : 'rejected';
-            return auswerten(koerper, fehlerName, antwort.status, inhaltstyp, geheimnisse, unlesbar);
+            return auswerten(koerper, fehlerName, antwort.status, inhaltstyp, geheimnisse, nachDemSenden);
         }
         finally {
             // Ohne Abraeumen haelt der Wecker den Node-Prozess bis zum Zeitlimit wach.

package/dist/esm/index.d.ts

@@ -1,6 +1,6 @@
 export { ReceiptType, type ReceiptTypeKey, VatRate, type VatRateKey, KeckPaymentMethod, type KeckPaymentMethodKey, CreditCardProvider, type CreditCardProviderKey, VoucherType, type VoucherTypeKey, VoucherAction, type VoucherActionKey, StripeLinkMode, type StripeLinkModeKey, } from './enums/index.js';
 export { type ReceiptItem, type ReceiptItemPayload, type ReceiptItemPayloadRead, toReceiptItemPayload, fromReceiptItemPayload, receiptItemTotalCents, receiptItemIsValid, negateReceiptItem, type TipRecipient, isTipItem, type Voucher, type VoucherPayload, toVoucherPayload, fromVoucherPayload, voucherIsValid, type Receipt, type RegistrationInfo, type ReceiptPayload, type ReceiptPayloadRead, toReceiptPayload, fromReceiptPayload, receiptSubSumCents, receiptSumCents, type CancellationOf, type CancellationItem, type Cancellation, type CancellationReason, type CancellationErrorCode, type CancellationStatus, type ReturnDisposition, RETURN_DISPOSITIONS, CANCELLATION_REASONS, CANCELLATION_STATUSES, CANCELLATION_ERROR_CODES, CANCELLATION_RESERVATION_MS, isCancellationReason, isReturnDisposition, isCancellationErrorCode, cancellationErrorCode, isCancellationError, cancellationFieldErrors, type CancellationFieldError, type ReceiptPayment, type ReceiptPaymentPayload, type ReceiptPaymentInput, fromReceiptPaymentPayload, toReceiptPaymentPayload, type PaymentErrorCode, PAYMENT_ERROR_CODES, isPaymentErrorCode, paymentErrorCode, isPaymentError, paymentFieldErrors, type PaymentFieldError, type ReceiptEmailErrorCode, type ReceiptEmailVia, RECEIPT_EMAIL_ERROR_CODES, RECEIPT_EMAIL_SEND_ERROR_CODES, type ReceiptEmailSendErrorCode, RECEIPT_EMAIL_VIAS, isReceiptEmailErrorCode, receiptEmailErrorCode, isReceiptEmailError, receiptEmailFieldErrors, type ReceiptEmailFieldError, type ReceiptErrorCode, type ReceiptFieldError, RECEIPT_ERROR_CODES, isReceiptErrorCode, receiptErrorCode, isReceiptError, receiptFieldErrors, remainingQuantities, type ReceiptCompany, type ReceiptCompanyPayload, fromReceiptCompanyPayload, receiptCompanyTaxInfo, type Cashregister, type CashregisterOnboarding, type CashregisterPayload, type CashregisterOnboardingPayload, fromCashregisterPayload, type ReceiptSummary, type ReceiptSummaryPayload, fromReceiptSummaryPayload, type ZeroKind, ZERO_KINDS, isZeroKind, type ReportMonth, reportMonthFromDate, previousReportMonth, nextReportMonth, reportMonthKey, reportMonthReadable, type StripeUrlSession, type StripeUrlSessionPayload, toStripeUrlSessionPayload, fromStripeUrlSessionPayload, type HobexReceipt, type HobexReceiptPayload, toHobexReceiptPayload, fromHobexReceiptPayload, hobexReceiptToCardPaymentData, hobexReceiptNeedsSignature, } from './models/index.js';
-export { type AuthCredentials, type KasseneckAuth, type ApiKeyAuthOptions, type RegisterUserAuthOptions, apiKeyAuth, registerUserAuth, DEFAULT_BASE_URL, POS_BASE_URL, DEFAULT_TIMEOUT_MS, type HttpResponseLike, type HttpRequestInit, type FetchLike, type TransportOptions, type TransportBodyFields, type KasseneckTransport, type KasseneckBinaryTransport, ALL_CALLS, type ApiCall, PUBLIC_CALLS, POS_CALLS, type PublicCall, type PosCall, createTransport, createBinaryTransport, KasseneckApiError, KasseneckAuthError, KasseneckHttpError, KasseneckNetworkError, KasseneckValidationError, type ValidationScope, type KasseneckError, type HttpFailureReason, type CauseDigest, type ErrorOutcome, CLIENT_ERROR_CODES, type ClientErrorCode, isKasseneckApiError, isKasseneckAuthError, isKasseneckHttpError, isKasseneckNetworkError, isKasseneckValidationError, isOutcomeUnknown, type ReceiptCommonOptions, type SellReceiptOptions, type TipOptions, type TipRecipientShare, type CancelReceiptOptions, type CancelReceiptResult, type ReceiptWithCompany, sellReceipt, sellReceiptWithCompany, paymentsExpectedCents, cardRefundReference, receiptLayoutFromResult, cancelReceipt, zeroReceipt, getReceipt, getReceiptWithCompany, generateFullReceiptId, getFirstReceiptDate, listMyReceipts, type ListMyReceiptsOptions, type ReceiptList, type ReceiptListStats, listMyCashregisters, checkVoucherCombinationError, type SendReceiptEmailOptions, type SendReceiptEmailResult, sendReceiptEmail, downloadDailyReport, downloadMonthlyReport, getReportV2, type ReportV2, type ReportV2Metadata, type ReportV2Options, type CashboxStatus, type SignatureStatus, getCashboxStatus, getSignatureStatus, type KasseneckApi, createKasseneckApi, } from './client/index.js';
+export { type AuthCredentials, type KasseneckAuth, type ApiKeyAuthOptions, type RegisterUserAuthOptions, apiKeyAuth, registerUserAuth, DEFAULT_BASE_URL, POS_BASE_URL, DEFAULT_TIMEOUT_MS, type HttpResponseLike, type HttpRequestInit, type FetchLike, type TransportOptions, type TransportBodyFields, type TransportCallOptions, type KasseneckTransport, type KasseneckBinaryTransport, ALL_CALLS, type ApiCall, PUBLIC_CALLS, POS_CALLS, UNKNOWN_OUTCOME_CALLS, type PublicCall, type PosCall, createTransport, createBinaryTransport, KasseneckApiError, KasseneckAuthError, KasseneckHttpError, KasseneckNetworkError, KasseneckValidationError, type ValidationScope, type KasseneckError, type HttpFailureReason, type CauseDigest, type ErrorOutcome, CLIENT_ERROR_CODES, type ClientErrorCode, isKasseneckApiError, isKasseneckAuthError, isKasseneckHttpError, isKasseneckNetworkError, isKasseneckValidationError, isOutcomeUnknown, type ReceiptCommonOptions, type SellReceiptOptions, type TipOptions, type TipRecipientShare, type CancelReceiptOptions, type CancelReceiptResult, type ReceiptWithCompany, sellReceipt, sellReceiptWithCompany, paymentsExpectedCents, cardRefundReference, receiptLayoutFromResult, cancelReceipt, zeroReceipt, getReceipt, getReceiptWithCompany, generateFullReceiptId, getFirstReceiptDate, listMyReceipts, type ListMyReceiptsOptions, type ReceiptList, type ReceiptListStats, listMyCashregisters, checkVoucherCombinationError, type SendReceiptEmailOptions, type SendReceiptEmailResult, sendReceiptEmail, downloadDailyReport, downloadMonthlyReport, getReportV2, type ReportV2, type ReportV2Metadata, type ReportV2Options, type CashboxStatus, type SignatureStatus, getCashboxStatus, getSignatureStatus, type KasseneckApi, createKasseneckApi, } from './client/index.js';
 export { type ReceiptDueTip, type ReceiptDueTipRecipient, type ReceiptDueOptions, type ReceiptDueBuckets, type ReceiptDueBreakdown, type ReceiptDueErrorReason, receiptDueCents, receiptDueBreakdown, ReceiptDueError, RECEIPT_DUE_ERROR_REASONS, isReceiptDueError, } from './receipt/due.js';
 export { parseServerTimeStamp, toViennaWallClock, type ViennaWallClock } from './vienna-time.js';
 export { type PosBusinessSettings, type PosDeviceSettings, type PosSettings, type ArticleGroup, type PosArticle, POS_BUSINESS_DEFAULTS, POS_DEVICE_DEFAULTS, mergePosSettings, fromArticleGroupPayload, fromPosArticlePayload, listMyArticleGroups, listMyArticles, getPosSettings, setMyPosSettings, setMyRegisterDeviceSettings, distributeDiscount, cancelScopeOf, receiptsScopeOf, stockViewOf, } from './pos/index.js';

package/dist/esm/index.js

@@ -1,6 +1,6 @@
 export { ReceiptType, VatRate, KeckPaymentMethod, CreditCardProvider, VoucherType, VoucherAction, StripeLinkMode, } from './enums/index.js';
 export { toReceiptItemPayload, fromReceiptItemPayload, receiptItemTotalCents, receiptItemIsValid, negateReceiptItem, isTipItem, toVoucherPayload, fromVoucherPayload, voucherIsValid, toReceiptPayload, fromReceiptPayload, receiptSubSumCents, receiptSumCents, RETURN_DISPOSITIONS, CANCELLATION_REASONS, CANCELLATION_STATUSES, CANCELLATION_ERROR_CODES, CANCELLATION_RESERVATION_MS, isCancellationReason, isReturnDisposition, isCancellationErrorCode, cancellationErrorCode, isCancellationError, cancellationFieldErrors, fromReceiptPaymentPayload, toReceiptPaymentPayload, PAYMENT_ERROR_CODES, isPaymentErrorCode, paymentErrorCode, isPaymentError, paymentFieldErrors, RECEIPT_EMAIL_ERROR_CODES, RECEIPT_EMAIL_SEND_ERROR_CODES, RECEIPT_EMAIL_VIAS, isReceiptEmailErrorCode, receiptEmailErrorCode, isReceiptEmailError, receiptEmailFieldErrors, RECEIPT_ERROR_CODES, isReceiptErrorCode, receiptErrorCode, isReceiptError, receiptFieldErrors, remainingQuantities, fromReceiptCompanyPayload, receiptCompanyTaxInfo, fromCashregisterPayload, fromReceiptSummaryPayload, ZERO_KINDS, isZeroKind, reportMonthFromDate, previousReportMonth, nextReportMonth, reportMonthKey, reportMonthReadable, toStripeUrlSessionPayload, fromStripeUrlSessionPayload, toHobexReceiptPayload, fromHobexReceiptPayload, hobexReceiptToCardPaymentData, hobexReceiptNeedsSignature, } from './models/index.js';
-export { apiKeyAuth, registerUserAuth, DEFAULT_BASE_URL, POS_BASE_URL, DEFAULT_TIMEOUT_MS, ALL_CALLS, PUBLIC_CALLS, POS_CALLS, createTransport, createBinaryTransport, KasseneckApiError, KasseneckAuthError, KasseneckHttpError, KasseneckNetworkError, KasseneckValidationError, CLIENT_ERROR_CODES, isKasseneckApiError, isKasseneckAuthError, isKasseneckHttpError, isKasseneckNetworkError, isKasseneckValidationError, isOutcomeUnknown, sellReceipt, sellReceiptWithCompany, paymentsExpectedCents, cardRefundReference, receiptLayoutFromResult, cancelReceipt, zeroReceipt, getReceipt, getReceiptWithCompany, generateFullReceiptId, getFirstReceiptDate, listMyReceipts, listMyCashregisters, checkVoucherCombinationError, sendReceiptEmail, downloadDailyReport, downloadMonthlyReport, getReportV2, getCashboxStatus, getSignatureStatus, createKasseneckApi, } from './client/index.js';
+export { apiKeyAuth, registerUserAuth, DEFAULT_BASE_URL, POS_BASE_URL, DEFAULT_TIMEOUT_MS, ALL_CALLS, PUBLIC_CALLS, POS_CALLS, UNKNOWN_OUTCOME_CALLS, createTransport, createBinaryTransport, KasseneckApiError, KasseneckAuthError, KasseneckHttpError, KasseneckNetworkError, KasseneckValidationError, CLIENT_ERROR_CODES, isKasseneckApiError, isKasseneckAuthError, isKasseneckHttpError, isKasseneckNetworkError, isKasseneckValidationError, isOutcomeUnknown, sellReceipt, sellReceiptWithCompany, paymentsExpectedCents, cardRefundReference, receiptLayoutFromResult, cancelReceipt, zeroReceipt, getReceipt, getReceiptWithCompany, generateFullReceiptId, getFirstReceiptDate, listMyReceipts, listMyCashregisters, checkVoucherCombinationError, sendReceiptEmail, downloadDailyReport, downloadMonthlyReport, getReportV2, getCashboxStatus, getSignatureStatus, createKasseneckApi, } from './client/index.js';
 export { receiptDueCents, receiptDueBreakdown, ReceiptDueError, RECEIPT_DUE_ERROR_REASONS, isReceiptDueError, } from './receipt/due.js';
 export { parseServerTimeStamp, toViennaWallClock } from './vienna-time.js';
 export { POS_BUSINESS_DEFAULTS, POS_DEVICE_DEFAULTS, mergePosSettings, fromArticleGroupPayload, fromPosArticlePayload, listMyArticleGroups, listMyArticles, getPosSettings, setMyPosSettings, setMyRegisterDeviceSettings, distributeDiscount, cancelScopeOf, receiptsScopeOf, stockViewOf, } from './pos/index.js';

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

@@ -23,6 +23,9 @@
  * **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.
+ * Darum meldet jeder schreibende Aufruf in diesen Faellen (auch HTTP 5xx und
+ * unlesbare Antwort) `outcome: 'unknown'`, nie `'rejected'`. Lesen und der
+ * Probelauf (`previewGoodsReceipt`) bleiben `'rejected'`.
  */
 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';

package/dist/esm/inventory/schreiben.js

@@ -23,6 +23,9 @@
  * **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.
+ * Darum meldet jeder schreibende Aufruf in diesen Faellen (auch HTTP 5xx und
+ * unlesbare Antwort) `outcome: 'unknown'`, nie `'rejected'`. Lesen und der
+ * Probelauf (`previewGoodsReceipt`) bleiben `'rejected'`.
  */
 import { abfrage, anfragefehler, kennung, seitenweise } from './endpunkte.js';
 import { artikel, liste, naechsterCursor, objekt, reservierung, vorgang, vorschauZeile } from './lesen.js';
@@ -197,7 +200,9 @@ export async function previewGoodsReceipt(transport, request) {
         delete p.idempotencyKey;
     schluessel(name, p, { pflicht: false });
     eingangZahlen(name, p);
-    const daten = await transport(name, { ...p, dryRun: true });
+    // Ein Probelauf schreibt nichts: nach einem Zeitlimit bleibt er `rejected`,
+    // obwohl `receiveGoods` sonst Wirkung hat.
+    const daten = await transport(name, { ...p, dryRun: true }, undefined, undefined, { hasEffect: false });
     return { preview: liste(name, daten, 'preview', vorschauZeile) };
 }
 const stueckPositionen = (name, p) => positionen(name, p.items, { pflicht: true, menge: 'pflicht' });

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

@@ -12,6 +12,12 @@
  * **Nicht automatisch wiederholen.** Wer nach einem Zeitlimit erneut
  * ausstellt, tut das mit **demselben** `idempotencyKey`: dann kommt die schon
  * ausgestellte Rechnung zurueck (`replayed: true`) statt einer zweiten.
+ * Jeder Aufruf mit Wirkung (ausstellen, stornieren, gutschreiben, Zahlung
+ * nachtragen, Kunde anlegen oder aendern) meldet nach Zeitlimit, Netzfehler,
+ * HTTP 5xx oder unlesbarer Antwort `outcome: 'unknown'`: er kann gewirkt
+ * haben. Mit Schluessel denselben Schluessel erneut senden, ohne Schluessel
+ * (`updateCustomer`, `createCustomer` ohne) erst nachlesen. Lesen und der
+ * Probelauf (`previewInvoice`) bleiben `'rejected'`.
  *
  * Nach dem Senden wird nichts hart gecastet: fehlt ein zugesagtes Feld, wirft
  * der Aufruf `KasseneckValidationError` mit `scope:'response'`.