@kreiseck/kasseneck-api 0.6.7

package/dist/cjs/payments/hobex.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hobexPay = hobexPay;
+exports.hobexRefund = hobexRefund;
+exports.newHobexTransactionId = newHobexTransactionId;
+const index_js_1 = require("../models/index.js");
+const errors_js_1 = require("../client/errors.js");
+const vienna_time_js_1 = require("../vienna-time.js");
+const money_js_1 = require("../money.js");
+/**
+ * Hobex-Kartenzahlung ueber die **Cloud-API** — Zwilling der Hobex-Aufrufe in
+ * kasseneck_api/lib/kasseneck_api.dart (Zeilen 491-526).
+ *
+ * Der Ablauf hat zwei Schritte: eine Kennung erzeugen ([newHobexTransactionId])
+ * und damit belasten ([hobexPay]). Die Kennung ist der Faden, an dem das
+ * Backend eine haengende Zahlung wiederfindet (`getHobexStatusWithTimeout`,
+ * functions/payment-endpoints.js) — sie ist deshalb kein Schmuck, sondern die
+ * Absicherung gegen eine doppelte Belastung.
+ *
+ * **Nur der Cloud-Weg ist hier drin, und das bleibt so.** Hobex **HPS** ist ein
+ * physisches Terminal, mit dem die Kasse **lokal ueber TCP** spricht; **myPOS**
+ * und **SumUp** sind **Android-SDKs**. Ein Browser hat weder rohe TCP-Sockets
+ * noch eine Android-Laufzeit — das ist keine fehlende Umsetzung und kein
+ * Buendler-Problem, sondern eine Grenze der Umgebung. Wer diese drei Wege
+ * braucht, braucht die Flutter-App, nicht dieses Paket.
+ *
+ * **Kassen-Benutzer-Weg (`registerUserAuth`, Browser-Kasse):** Keiner der
+ * beiden Endpunkte dieser Datei setzt `allowRegisterUser`; beide laufen nur
+ * mit `apiKeyAuth`. Ausgefuehrt steht das in payments/index.ts — an einer
+ * Stelle statt an dreien.
+ */
+/** Endpunktnamen aus dem Vorbild — beide mit Suffix `Api`. */
+const ENDPUNKT_PAY = 'hobexPayApi';
+const ENDPUNKT_REFUND = 'hobexRefundApi';
+/**
+ * Belastet eine Karte ueber die **Hobex-Cloud-API** und liefert den
+ * entstandenen [HobexReceipt].
+ *
+ * **Der Endpunkt heisst `hobexPayApi`** — mit Suffix; ohne ihn gibt es ihn
+ * nicht.
+ */
+async function hobexPay(rufen, options) {
+    const params = zahlungsNutzlast(ENDPUNKT_PAY, options);
+    // `reference` steht im Vorbild **unbedingt** in der Nutzlast: ohne Angabe
+    // geht sie als null raus, nicht gar nicht. Der Transport wirft nur
+    // `undefined` weg, `null` bleibt erhalten — genau diese Unterscheidung.
+    params['reference'] = options.reference ?? null;
+    return belegAusNutzlast(await rufen(ENDPUNKT_PAY, params));
+}
+/**
+ * Erstattet eine zuvor ueber die Hobex-Cloud getaetigte Zahlung. Das Backend
+ * storniert zuerst (Void, solange der Tagesabschluss aussteht) und erstattet
+ * erst danach.
+ *
+ * **Ohne Rueckgabewert, mit Absicht.** Das Vorbild liefert
+ * `resJson['status'] == 'success'`; in diesem Paket wirft die Fehlerhuelle
+ * schon im Transport, sobald der Status nicht ausdruecklich Erfolg ist. Ein
+ * Wahrheitswert waere hier also immer `true` — eine Luege ueber den
+ * Informationsgehalt, an der ein Aufrufer ein `if` aufhaengt, das nie greift.
+ * Misserfolg kommt als geworfener Fehler.
+ *
+ * **Der Endpunkt heisst `hobexRefundApi`** — mit Suffix.
+ */
+async function hobexRefund(rufen, options) {
+    // Anders als die Zahlung sendet der Refund im Vorbild **keine** reference.
+    await rufen(ENDPUNKT_REFUND, zahlungsNutzlast(ENDPUNKT_REFUND, options));
+}
+/**
+ * Erzeugt eine neue Hobex-Transaktionskennung: 19 Ziffern aus Zeitanteil und
+ * Zufall (Zwilling von `newHobexTransactionId` im Vorbild, Zeile 522).
+ *
+ * Zwei bewusste Abweichungen:
+ *
+ * 1. **Wiener Wanduhrzeit statt Geraetezeit.** Das Vorbild nimmt
+ *    `DateTime.now()` in der Zeitzone des Geraets; damit haetten zwei Kassen
+ *    desselben Betriebs in verschiedenen Zeitzonen Kennungen, die sich um
+ *    Stunden unterscheiden, und der Tageswechsel in der Kennung faende nicht
+ *    zum Geschaeftstag statt. Fachlich ist Wien die Zeitzone (siehe
+ *    vienna-time.ts) — und eine Browser-Kasse laeuft in der Zeitzone des Gasts,
+ *    nicht des Betriebs.
+ * 2. **Millisekunden statt Mikrosekunden.** JavaScript hat keine
+ *    Mikrosekunden-Uhr. Das Vorbild fuellt mit sechs Bruchteilsstellen auf und
+ *    haengt zwei Zufallsziffern an, von denen die Laengenbegrenzung eine wieder
+ *    abschneidet; hier stehen drei Bruchteilsstellen und vier Zufallsziffern.
+ *    Laenge und Form (nur Ziffern, 19 Stellen, `JJMMTThhmmss` voran) bleiben
+ *    gleich.
+ *
+ * Zeit- und Zufallsquelle sind einspeisbar, damit die Kennung pruefbar ist.
+ */
+function newHobexTransactionId(options = {}) {
+    const wand = (0, vienna_time_js_1.toViennaWallClock)(options.now ?? new Date());
+    const zufall = options.random ?? Math.random;
+    const zeitanteil = zweistellig(wand.year % 100) +
+        zweistellig(wand.month) +
+        zweistellig(wand.day) +
+        zweistellig(wand.hour) +
+        zweistellig(wand.minute) +
+        zweistellig(wand.second) +
+        String(wand.millisecond).padStart(3, '0');
+    // Vier Ziffern, immer vierstellig: eine kuerzere Zahl wuerde die Kennung
+    // verkuerzen und damit ihre Form verlassen. Der Wert wird auf [0, 1)
+    // begrenzt — eine fremde Zufallsquelle koennte 1 liefern.
+    const zufallsanteil = String(Math.floor(begrenzt(zufall()) * 10_000)).padStart(4, '0');
+    return zeitanteil + zufallsanteil;
+}
+/**
+ * Gemeinsame Nutzlast beider Hobex-Aufrufe: Kennung und die beiden Betraege in
+ * Euro. Prueft, bevor irgendetwas rausgeht — hier bewegt sich Geld auf einer
+ * fremden Karte, und ein NaN-Betrag oder eine leere Kennung ist an einem
+ * Zahlungsterminal nichts, was man dem Backend zum Ausprobieren schickt.
+ */
+function zahlungsNutzlast(functionName, options) {
+    if (typeof options.transactionId !== 'string' || !options.transactionId.trim()) {
+        throw eingabefehler(functionName, 'transactionId fehlt');
+    }
+    const amountCents = gepruefterBetrag(functionName, options.amountCents, 'amountCents', 1);
+    const tipCents = gepruefterBetrag(functionName, options.tipCents ?? 0, 'tipCents', 0);
+    return {
+        transactionId: options.transactionId,
+        // Euro-Umrechnung genau hier, an der Hobex-Grenze.
+        amount: (0, money_js_1.centsToEuro)(amountCents),
+        tip: (0, money_js_1.centsToEuro)(tipCents),
+    };
+}
+/**
+ * Ganzzahliger Cent-Betrag ab [mindestens]. `Number.isInteger` faengt NaN,
+ * Unendlich und Bruchteils-Cent in einem — ein halber Cent ergibt bei der
+ * Euro-Umrechnung eine dritte Nachkommastelle, die Hobex nicht kennt.
+ */
+function gepruefterBetrag(functionName, cents, feld, mindestens) {
+    if (!Number.isInteger(cents)) {
+        throw eingabefehler(functionName, `${feld} muss eine ganze Zahl in Cent sein.`);
+    }
+    if (cents < mindestens) {
+        throw eingabefehler(functionName, `${feld} muss mindestens ${mindestens} Cent betragen.`);
+    }
+    return cents;
+}
+/**
+ * Hobex-Beleg aus der Antwort lesen. Geprueft werden die beiden Felder, ohne
+ * die der Beleg nichts wert ist: die Kennung der Zahlung und der Zeitstempel
+ * (an ihm scheitert die Lesart des Modells sonst mit einem nackten TypeError,
+ * weil sie ihn zerlegt). Die uebrigen Felder bleiben so tolerant wie im
+ * Vorbild — ein Beleg, dem Hobex den Kartenaussteller schuldig bleibt, ist
+ * trotzdem eine erfolgte Zahlung.
+ */
+function belegAusNutzlast(daten) {
+    const roh = daten;
+    if (roh == null ||
+        typeof roh !== 'object' ||
+        typeof roh.transactionId !== 'string' ||
+        typeof roh.transactionDate !== 'string') {
+        throw antwortfehler(ENDPUNKT_PAY, 'Antwort enthaelt keinen Hobex-Beleg');
+    }
+    return (0, index_js_1.fromHobexReceiptPayload)(roh);
+}
+const zweistellig = (wert) => String(wert).padStart(2, '0');
+/** Auf `[0, 1)` begrenzen — eine fremde Zufallsquelle haelt sich nicht daran. */
+const begrenzt = (wert) => (Number.isFinite(wert) ? Math.min(Math.max(wert, 0), 0.999_999_9) : 0);
+/** Fehler in der Eingabe des Aufrufers — es geht keine Anfrage raus. */
+function eingabefehler(functionName, grund) {
+    return new errors_js_1.KasseneckValidationError(functionName, grund, 'request');
+}
+/** Die Antwort meldete Erfolg, trug aber nicht, was der Aufruf zusagt. */
+function antwortfehler(functionName, grund) {
+    return new errors_js_1.KasseneckValidationError(functionName, grund, 'response');
+}

package/dist/cjs/payments/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Unterpfad `@kreiseck/kasseneck-api/payments` — die Zahlungswege, die ein
+ * Browser oder ein Node-Prozess wirklich gehen kann: **Stripe-Zahlungslinks**
+ * (Fernzahlung per Link/QR-Code) und die **Hobex-Cloud-API** (Kartenzahlung
+ * ueber ein bei Hobex registriertes Terminal, gesteuert ueber das Netz).
+ *
+ * **Was hier bewusst fehlt — und warum es auch nicht nachgeruestet wird:**
+ *
+ * - **Hobex HPS** spricht **lokal ueber TCP** mit einem angeschlossenen
+ *   Terminal (roher Socket auf eine Geraete-IP im selben Netz).
+ * - **myPOS** und **SumUp** sind **Android-SDKs**; sie laufen als
+ *   Bibliothek in einer Android-App und reden ueber Bluetooth bzw. das
+ *   Hersteller-Geraet mit dem Terminal.
+ *
+ * Ein Browser hat weder rohe TCP-Sockets noch eine Android-Laufzeit. Das ist
+ * keine Luecke in diesem Paket und auch nichts, was ein anderer Buendler,
+ * ein Polyfill oder eine WebAssembly-Schicht aufloest — es ist eine Grenze der
+ * Umgebung. Diese drei Wege gibt es im Flutter-Paket `kasseneck_api`, und dort
+ * bleiben sie.
+ *
+ * **Kassen-Benutzer-Weg (`registerUserAuth`, Browser-Kasse):** **Keiner** der
+ * vier Zahlungs-Endpunkte setzt `allowRegisterUser`; sie laufen alle ueber
+ * `checkRequest(req, 'user', …)` und damit nur mit `apiKeyAuth`. Dieses Paket
+ * bildet das **nicht** nach — wer darf, entscheidet allein das Backend. Der
+ * Hinweis steht **hier** und gilt fuer beide Dateien dieses Unterpfads.
+ *
+ * Welche **anderen** Endpunkte den Weg offen haben, steht bewusst nirgends in
+ * diesem Paket: eine abgeschriebene Liste veraltet still, und sie hat hier
+ * nichts zu entscheiden.
+ */
+export { StripeLinkMode, type StripeLinkModeKey } from '../enums/index.js';
+export { type CreateStripeLinkOptions, type StripeCaptureResult, createStripeLink, stripeCaptureIntent, } from './stripe.js';
+export { type HobexPayOptions, type HobexRefundOptions, type HobexTransactionIdOptions, hobexPay, hobexRefund, newHobexTransactionId, } from './hobex.js';

package/dist/cjs/payments/index.js

@@ -0,0 +1,42 @@
+"use strict";
+/**
+ * Unterpfad `@kreiseck/kasseneck-api/payments` — die Zahlungswege, die ein
+ * Browser oder ein Node-Prozess wirklich gehen kann: **Stripe-Zahlungslinks**
+ * (Fernzahlung per Link/QR-Code) und die **Hobex-Cloud-API** (Kartenzahlung
+ * ueber ein bei Hobex registriertes Terminal, gesteuert ueber das Netz).
+ *
+ * **Was hier bewusst fehlt — und warum es auch nicht nachgeruestet wird:**
+ *
+ * - **Hobex HPS** spricht **lokal ueber TCP** mit einem angeschlossenen
+ *   Terminal (roher Socket auf eine Geraete-IP im selben Netz).
+ * - **myPOS** und **SumUp** sind **Android-SDKs**; sie laufen als
+ *   Bibliothek in einer Android-App und reden ueber Bluetooth bzw. das
+ *   Hersteller-Geraet mit dem Terminal.
+ *
+ * Ein Browser hat weder rohe TCP-Sockets noch eine Android-Laufzeit. Das ist
+ * keine Luecke in diesem Paket und auch nichts, was ein anderer Buendler,
+ * ein Polyfill oder eine WebAssembly-Schicht aufloest — es ist eine Grenze der
+ * Umgebung. Diese drei Wege gibt es im Flutter-Paket `kasseneck_api`, und dort
+ * bleiben sie.
+ *
+ * **Kassen-Benutzer-Weg (`registerUserAuth`, Browser-Kasse):** **Keiner** der
+ * vier Zahlungs-Endpunkte setzt `allowRegisterUser`; sie laufen alle ueber
+ * `checkRequest(req, 'user', …)` und damit nur mit `apiKeyAuth`. Dieses Paket
+ * bildet das **nicht** nach — wer darf, entscheidet allein das Backend. Der
+ * Hinweis steht **hier** und gilt fuer beide Dateien dieses Unterpfads.
+ *
+ * Welche **anderen** Endpunkte den Weg offen haben, steht bewusst nirgends in
+ * diesem Paket: eine abgeschriebene Liste veraltet still, und sie hat hier
+ * nichts zu entscheiden.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newHobexTransactionId = exports.hobexRefund = exports.hobexPay = exports.stripeCaptureIntent = exports.createStripeLink = exports.StripeLinkMode = void 0;
+var index_js_1 = require("../enums/index.js");
+Object.defineProperty(exports, "StripeLinkMode", { enumerable: true, get: function () { return index_js_1.StripeLinkMode; } });
+var stripe_js_1 = require("./stripe.js");
+Object.defineProperty(exports, "createStripeLink", { enumerable: true, get: function () { return stripe_js_1.createStripeLink; } });
+Object.defineProperty(exports, "stripeCaptureIntent", { enumerable: true, get: function () { return stripe_js_1.stripeCaptureIntent; } });
+var hobex_js_1 = require("./hobex.js");
+Object.defineProperty(exports, "hobexPay", { enumerable: true, get: function () { return hobex_js_1.hobexPay; } });
+Object.defineProperty(exports, "hobexRefund", { enumerable: true, get: function () { return hobex_js_1.hobexRefund; } });
+Object.defineProperty(exports, "newHobexTransactionId", { enumerable: true, get: function () { return hobex_js_1.newHobexTransactionId; } });

package/dist/cjs/payments/stripe.d.ts

@@ -0,0 +1,61 @@
+import { StripeLinkMode, type StripeLinkModeKey } from '../enums/index.js';
+import { type ReceiptItem, type StripeUrlSession } from '../models/index.js';
+import type { KasseneckTransport } from '../client/transport.js';
+export interface CreateStripeLinkOptions {
+    /** Positionen des Zahlungslinks; mindestens eine, alle gueltig. */
+    items: ReceiptItem[];
+    /** Soll das Backend nach bezahltem Link selbsttaetig einen Beleg erzeugen? */
+    createReceiptAfterPayment: boolean;
+    /** Sofort einziehen (`payment`) oder nur reservieren (`authorization`). */
+    mode: StripeLinkMode | StripeLinkModeKey;
+    /** Eigener Bezeichner fuer den Zahlungs-Webhook des Aufrufers. */
+    webhookId?: string;
+    /** Telefonnummer des Gasts (landet in den Stripe-Metadaten). */
+    customerPhone?: string;
+    /** E-Mail des Gasts (Stripe schickt die Zahlungsbestaetigung dorthin). */
+    customerEmail?: string;
+}
+/**
+ * Ergebnis von [stripeCaptureIntent] — das eingezogene Zahlungsversprechen
+ * (Stripe PaymentIntent), **nicht** noch einmal die Zahlungslink-Sitzung.
+ *
+ * Das ist eine bewusste Abweichung vom Dart-Vorbild: dort steht
+ * `StripeUrlSession.fromJson(resJson['data'])`, das Backend antwortet an dieser
+ * Stelle aber mit `{id, status, amount_received, currency}` (successResponse in
+ * functions/payment-endpoints.js). Weder `url` noch `shorten_payment_url` noch
+ * `expires_at` sind darin — die Sitzungs-Lesart kann hier gar nicht gelingen.
+ */
+export interface StripeCaptureResult {
+    /** Bezeichner des PaymentIntent (`pi_…`), nicht der der Sitzung (`cs_…`). */
+    id: string;
+    /** Stripe-Status des Einzugs, z. B. `succeeded`. */
+    status: string;
+    /**
+     * Tatsaechlich eingezogener Betrag in Cent. Stripe fuehrt Betraege in der
+     * kleinsten Waehrungseinheit; der Name unterstellt damit eine
+     * zweistellige Waehrung. Fuer diese Anlage stimmt das — das Backend legt
+     * `currency: 'eur'` fest (functions/payment-endpoints.js). Bei einer
+     * nullstelligen Waehrung (JPY) waere „Cent" der falsche Name; dann gehoert
+     * die Einheit aus `currency` abgeleitet und nicht in den Feldnamen.
+     */
+    amountReceivedCents: number;
+    /** Waehrungscode, wie Stripe ihn fuehrt (klein geschrieben, z. B. `eur`). */
+    currency: string;
+}
+/**
+ * Erzeugt einen Stripe-Zahlungslink fuer [items] (Fernzahlung: Link per
+ * Nachricht, QR-Code oder Kurzlink).
+ *
+ * **Der Endpunkt heisst `createPaymentLinkStripe`**, nicht wie diese Funktion —
+ * Methodenname und Endpunktname fallen wie schon beim Monatsbericht
+ * auseinander (siehe client/reports.ts).
+ */
+export declare function createStripeLink(rufen: KasseneckTransport, options: CreateStripeLinkOptions): Promise<StripeUrlSession>;
+/**
+ * Zieht die zuvor nur reservierte Zahlung einer `authorization`-Sitzung ein.
+ *
+ * **Der Parameter heisst `stripe_sessions_id`** — mit "sessions" im Plural, so
+ * das Vorbild und so das Backend. Der naheliegende Singular waere ein fehlender
+ * Pflichtparameter.
+ */
+export declare function stripeCaptureIntent(rufen: KasseneckTransport, stripeSessionId: string): Promise<StripeCaptureResult>;

package/dist/cjs/payments/stripe.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStripeLink = createStripeLink;
+exports.stripeCaptureIntent = stripeCaptureIntent;
+const index_js_1 = require("../enums/index.js");
+const index_js_2 = require("../models/index.js");
+const errors_js_1 = require("../client/errors.js");
+/**
+ * Stripe-Zahlungslinks — Zwilling der Stripe-Aufrufe in
+ * kasseneck_api/lib/kasseneck_api.dart (Zeilen 443-484).
+ *
+ * Zwei Aufrufe: [createStripeLink] erzeugt eine Checkout-Sitzung samt Kurzlink
+ * (`pay.kasseneck.at/…`), den der Gast oeffnet; [stripeCaptureIntent] zieht die
+ * zuvor nur reservierte Zahlung eines `authorization`-Links spaeter ein.
+ *
+ * **Kassen-Benutzer-Weg (`registerUserAuth`, Browser-Kasse):** Keiner der
+ * beiden Endpunkte dieser Datei setzt `allowRegisterUser`; beide laufen nur
+ * mit `apiKeyAuth`. Ausgefuehrt steht das in payments/index.ts — an einer
+ * Stelle statt an dreien.
+ */
+/** Endpunktname aus dem Vorbild — **nicht** `createStripeLink`. */
+const ENDPUNKT_LINK = 'createPaymentLinkStripe';
+const ENDPUNKT_CAPTURE = 'stripeCaptureIntent';
+/**
+ * Erzeugt einen Stripe-Zahlungslink fuer [items] (Fernzahlung: Link per
+ * Nachricht, QR-Code oder Kurzlink).
+ *
+ * **Der Endpunkt heisst `createPaymentLinkStripe`**, nicht wie diese Funktion —
+ * Methodenname und Endpunktname fallen wie schon beim Monatsbericht
+ * auseinander (siehe client/reports.ts).
+ */
+async function createStripeLink(rufen, options) {
+    const { items } = options;
+    // Vor dem Senden pruefen: ein Zahlungslink ist zwar folgenlos wiederholbar,
+    // eine abgewiesene Anfrage aber eine unnoetige Runde ueber das Netz — und der
+    // Backend-Fehlertext nennt den Grund weit weniger genau als diese Pruefung.
+    if (!Array.isArray(items) || items.length === 0) {
+        throw eingabefehler(ENDPUNKT_LINK, 'Positionen sind Pflicht und duerfen nicht leer sein.');
+    }
+    if (items.some((item) => !(0, index_js_2.receiptItemIsValid)(item))) {
+        throw eingabefehler(ENDPUNKT_LINK, 'Ungueltige Position uebergeben.');
+    }
+    const params = {
+        items: positionsNutzlast(items),
+        createReceiptAfterPayment: options.createReceiptAfterPayment,
+        // Im Vorbild `mode.name`; Schluessel und Wert sind hier identisch.
+        mode: gepruefterModus(options.mode),
+    };
+    // Die drei uebrigen Felder stehen im Vorbild unter `if (… != null)` — ohne
+    // Angabe geht kein leeres Feld raus.
+    if (options.webhookId != null) {
+        params['webhookId'] = options.webhookId;
+    }
+    // **Abweichung vom Vorbild, mit Absicht:** Dart sendet `customerPhone`/
+    // `customerEmail` in camelCase. Das Backend nimmt die beiden Felder aber
+    // ausschliesslich als `customer_phone`/`customer_email` entgegen (so stehen
+    // sie in den optionalParams von `createPaymentLinkStripe`, und nur so werden
+    // sie ausgewertet), und unbekannte Parameter weist `checkRequest` nicht ab —
+    // sie fallen still unter den Tisch. Wer die camelCase-Namen uebernaehme,
+    // gaebe dem Aufrufer zwei Felder, die nachweislich nichts bewirken.
+    if (options.customerPhone != null) {
+        params['customer_phone'] = options.customerPhone;
+    }
+    if (options.customerEmail != null) {
+        params['customer_email'] = options.customerEmail;
+    }
+    return sitzungAusNutzlast(await rufen(ENDPUNKT_LINK, params));
+}
+/**
+ * Zieht die zuvor nur reservierte Zahlung einer `authorization`-Sitzung ein.
+ *
+ * **Der Parameter heisst `stripe_sessions_id`** — mit "sessions" im Plural, so
+ * das Vorbild und so das Backend. Der naheliegende Singular waere ein fehlender
+ * Pflichtparameter.
+ */
+async function stripeCaptureIntent(rufen, stripeSessionId) {
+    if (typeof stripeSessionId !== 'string' || !stripeSessionId.trim()) {
+        throw eingabefehler(ENDPUNKT_CAPTURE, 'stripeSessionId fehlt');
+    }
+    const daten = await rufen(ENDPUNKT_CAPTURE, { stripe_sessions_id: stripeSessionId });
+    return einzugAusNutzlast(daten);
+}
+/**
+ * Positionen in ihre Nutzlast wandeln und dabei die strenge Schreibpfad-
+ * Pruefung des Modells abfangen (unbekannter Steuersatz). Das Modell wirft dort
+ * ein nacktes `Error`; aus einem Endpunkt-Aufruf soll nur die Fehler-Union
+ * dieses Pakets herauskommen (dasselbe Vorgehen wie in client/receipts.ts).
+ */
+function positionsNutzlast(items) {
+    try {
+        return items.map(index_js_2.toReceiptItemPayload);
+    }
+    catch (ursache) {
+        throw eingabefehler(ENDPUNKT_LINK, ursache instanceof Error ? ursache.message : 'Ungueltige Nutzlast uebergeben.');
+    }
+}
+/**
+ * Modus aufloesen. Bleibt streng: der Modus kommt vom Aufrufer, und das Backend
+ * kennt genau zwei Werte — ein dritter waere ein Programmierfehler, der sonst
+ * still als `payment` durchginge (das Backend setzt `capture_method: 'manual'`
+ * nur bei genau 'authorization').
+ */
+function gepruefterModus(wert) {
+    if (!Object.prototype.hasOwnProperty.call(index_js_1.StripeLinkMode, wert)) {
+        throw eingabefehler(ENDPUNKT_LINK, `Stripe-Link-Modus: unbekannter Wert "${String(wert)}"`);
+    }
+    return index_js_1.StripeLinkMode[wert];
+}
+/**
+ * Zahlungslink-Sitzung aus der Antwort lesen. Alle vier Felder muessen da sein:
+ * eine Sitzung ohne `url` ist kein Zahlungslink, und ein unlesbares Ablaufdatum
+ * wuerde als `Invalid Date` weiterwandern und erst beim Anzeigen auffallen.
+ */
+function sitzungAusNutzlast(daten) {
+    const roh = daten;
+    if (roh == null ||
+        typeof roh !== 'object' ||
+        typeof roh.id !== 'string' ||
+        typeof roh.url !== 'string' ||
+        typeof roh.shorten_payment_url !== 'string' ||
+        typeof roh.expires_at !== 'string') {
+        throw antwortfehler(ENDPUNKT_LINK, 'Antwort enthaelt keine Zahlungslink-Sitzung');
+    }
+    const sitzung = (0, index_js_2.fromStripeUrlSessionPayload)(roh);
+    if (Number.isNaN(sitzung.expiresAt.getTime())) {
+        throw antwortfehler(ENDPUNKT_LINK, 'Antwort enthaelt kein lesbares Ablaufdatum');
+    }
+    return sitzung;
+}
+/** Ergebnis des Einzugs aus der Antwort lesen (Felder siehe [StripeCaptureResult]). */
+function einzugAusNutzlast(daten) {
+    const roh = daten;
+    if (roh == null ||
+        typeof roh !== 'object' ||
+        typeof roh.id !== 'string' ||
+        typeof roh.status !== 'string' ||
+        typeof roh.amount_received !== 'number' ||
+        typeof roh.currency !== 'string') {
+        throw antwortfehler(ENDPUNKT_CAPTURE, 'Antwort enthaelt kein eingezogenes Zahlungsversprechen');
+    }
+    return {
+        id: roh.id,
+        status: roh.status,
+        // Stripe fuehrt Betraege in der kleinsten Waehrungseinheit — hier bereits
+        // Cent, es wird also nichts umgerechnet (anders als bei Hobex).
+        amountReceivedCents: roh.amount_received,
+        currency: roh.currency,
+    };
+}
+/** Fehler in der Eingabe des Aufrufers — es geht keine Anfrage raus. */
+function eingabefehler(functionName, grund) {
+    return new errors_js_1.KasseneckValidationError(functionName, grund, 'request');
+}
+/** Die Antwort meldete Erfolg, trug aber nicht, was der Aufruf zusagt. */
+function antwortfehler(functionName, grund) {
+    return new errors_js_1.KasseneckValidationError(functionName, grund, 'response');
+}