@kreiseck/kasseneck-api 0.6.46 → 0.7.0

package/dist/cjs/partner/ablauf.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Der Weg vom Vertragsabschluss bis zum ersten Beleg — als Daten, nicht als
+ * Fliesstext.
+ *
+ * **Warum das im Paket steht und nicht nur in der Doku:** die Kette hat eine
+ * harte Reihenfolge, und jeder Schritt scheitert mit einem eigenen Code, wenn
+ * ein vorheriger fehlt (`fon_missing`, `signature_missing`,
+ * `signature_not_ready`).
+ * Wer die Reihenfolge nur aus einer Fehlermeldung lernt, lernt sie einmal je
+ * Fehler. Hier steht sie vorher — abfragbar, ausgebbar, und in
+ * [naechsterSchritt] auch beantwortbar.
+ *
+ * **Ohne Vertragsschritt.** Auftragsverarbeitungsvertraege wirken in diesem
+ * Weg nicht mehr (Stand 2026-08-31): kein Aufruf meldet einen, keine Kasse
+ * bleibt deswegen stehen.
+ *
+ * Zwei Dinge laufen bewusst **parallel**: der Signaturantrag und das Anlegen
+ * der Kasse. Eine mit `automatic:true` angelegte Kasse wartet, bis die
+ * Signatur bereit ist, und geht dann von selbst live. Der Kundenstatus nennt
+ * darum immer nur den **weitesten erreichten** Meilenstein, nicht die einzige
+ * laufende Arbeit.
+ */
+import type { KundenStatus } from './typen.js';
+/** Ein Schritt der Kette. */
+export interface AblaufSchritt {
+    key: string;
+    /** Was in diesem Schritt passiert. */
+    text: string;
+    /** Der Aufruf, der ihn ausloest — `null`, wenn hier nur gewartet wird. */
+    aufruf: string | null;
+    /** Das Ereignis, das seinen Abschluss meldet — `null`, wenn es sofort feststeht. */
+    wartetAuf: string | null;
+    /** Der Fehlercode, mit dem ein spaeterer Aufruf sich beschwert, wenn dieser Schritt fehlt. */
+    fehltCode: string | null;
+}
+/**
+ * Die Kette in ihrer Reihenfolge. Sie beschreibt den **Live-Weg**; mit einem
+ * `pk_test_`-Schluessel entfallen die FinanzOnline-Schritte, und die Signatur
+ * ist sofort bereit (AT100-Testkarte — die damit erzeugten Belege sind keine
+ * gueltigen RKSV-Belege).
+ */
+export declare const PARTNER_ABLAUF: readonly AblaufSchritt[];
+/**
+ * Der Schritt, an dem ein Betrieb mit diesem Status steht — `null` fuer
+ * `gesperrt` und fuer jeden Status, den dieses Paket nicht kennt.
+ */
+export declare function naechsterSchritt(status: KundenStatus): AblaufSchritt | null;

package/dist/cjs/partner/ablauf.js

@@ -0,0 +1,99 @@
+"use strict";
+/**
+ * Der Weg vom Vertragsabschluss bis zum ersten Beleg — als Daten, nicht als
+ * Fliesstext.
+ *
+ * **Warum das im Paket steht und nicht nur in der Doku:** die Kette hat eine
+ * harte Reihenfolge, und jeder Schritt scheitert mit einem eigenen Code, wenn
+ * ein vorheriger fehlt (`fon_missing`, `signature_missing`,
+ * `signature_not_ready`).
+ * Wer die Reihenfolge nur aus einer Fehlermeldung lernt, lernt sie einmal je
+ * Fehler. Hier steht sie vorher — abfragbar, ausgebbar, und in
+ * [naechsterSchritt] auch beantwortbar.
+ *
+ * **Ohne Vertragsschritt.** Auftragsverarbeitungsvertraege wirken in diesem
+ * Weg nicht mehr (Stand 2026-08-31): kein Aufruf meldet einen, keine Kasse
+ * bleibt deswegen stehen.
+ *
+ * Zwei Dinge laufen bewusst **parallel**: der Signaturantrag und das Anlegen
+ * der Kasse. Eine mit `automatic:true` angelegte Kasse wartet, bis die
+ * Signatur bereit ist, und geht dann von selbst live. Der Kundenstatus nennt
+ * darum immer nur den **weitesten erreichten** Meilenstein, nicht die einzige
+ * laufende Arbeit.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PARTNER_ABLAUF = void 0;
+exports.naechsterSchritt = naechsterSchritt;
+/**
+ * Die Kette in ihrer Reihenfolge. Sie beschreibt den **Live-Weg**; mit einem
+ * `pk_test_`-Schluessel entfallen die FinanzOnline-Schritte, und die Signatur
+ * ist sofort bereit (AT100-Testkarte — die damit erzeugten Belege sind keine
+ * gueltigen RKSV-Belege).
+ */
+exports.PARTNER_ABLAUF = [
+    {
+        key: 'business',
+        text: 'Betrieb anlegen (idempotencyKey = eigene Kundennummer).',
+        aufruf: 'createPartnerCustomer',
+        wartetAuf: 'customer.created',
+        fehltCode: null,
+    },
+    {
+        key: 'fon',
+        text: 'FinanzOnline einrichten: Link an den Betrieb, der Betrieb traegt seinen Zugang ein.',
+        aufruf: 'sendPartnerCustomerFonLink',
+        wartetAuf: 'customer.fon_verified',
+        fehltCode: 'fon_missing',
+    },
+    {
+        key: 'signature',
+        text: 'Signatureinheit beantragen. Kasseneck weist eine Karte zu und meldet sie bei FinanzOnline an.',
+        aufruf: 'requestCustomerSignature',
+        wartetAuf: 'signature.ready',
+        fehltCode: 'signature_missing',
+    },
+    {
+        key: 'cashregister',
+        text: 'Kasse anlegen. Mit automatic:true (Vorgabe) geht sie von selbst live, sobald die Signatur bereit ist — ' +
+            'sie darf deshalb schon vorher angelegt werden.',
+        aufruf: 'createCustomerCashregister',
+        wartetAuf: 'cashregister.live',
+        fehltCode: 'cashregister_not_found',
+    },
+    {
+        key: 'zugangsdaten',
+        text: 'Zugangsdaten des Betriebs holen (Scope credentials:read). Geheimnisse — nur verschluesselt speichern.',
+        aufruf: 'getCustomerCredentials',
+        wartetAuf: null,
+        fehltCode: null,
+    },
+    {
+        key: 'belege',
+        text: 'Belege signieren: Bearer = apiKey des Betriebs, Kopfzeile cashregister-token = Token der Kasse.',
+        aufruf: 'createReceipt',
+        wartetAuf: null,
+        fehltCode: null,
+    },
+];
+/**
+ * Welcher Meilenstein einem Kundenstatus entspricht. Die Zuordnung ist
+ * absichtlich grob: der Status nennt den weitesten erreichten Punkt, nicht die
+ * laufende Arbeit — fuer den genauen Verlauf sind die Ereignisse `signature.*`
+ * und `cashregister.*` da.
+ */
+const STATUS_SCHRITT = {
+    created: 'fon',
+    fon_configured: 'signature',
+    signature_requested: 'signature',
+    signature_ready: 'cashregister',
+    cashregister_created: 'cashregister',
+    live: 'zugangsdaten',
+};
+/**
+ * Der Schritt, an dem ein Betrieb mit diesem Status steht — `null` fuer
+ * `gesperrt` und fuer jeden Status, den dieses Paket nicht kennt.
+ */
+function naechsterSchritt(status) {
+    const key = STATUS_SCHRITT[status];
+    return key ? exports.PARTNER_ABLAUF.find((s) => s.key === key) ?? null : null;
+}

package/dist/cjs/partner/api.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Fassade ueber den Partner-Aufrufen: Schluessel einmal binden, dann rufen.
+ *
+ * Wie [createKasseneckApi] bewusst **keine** Klasse — die Aufrufe sind freie
+ * Funktionen und bleiben einzeln importierbar.
+ */
+import { type FetchLike } from '../client/transport.js';
+import { type CreateWebhookOptions, type CreateWebhookResult, type PartnerWebhook, type WebhookListe, type PartnerWebhookEventType, type WebhookPatch, type WebhookTestResult, type WebhookZustellung } from './webhooks.js';
+import type { ActivateCashregisterResult, CreateCashregisterOptions, CreateCashregisterResult, CreateCustomerOptions, CreateCustomerResult, CustomerCredentials, FonLinkResult, KassenListe, Kunde, KundenListe, ListCustomersOptions, PartnerInfo, RequestSignatureResult, SignaturStand } from './typen.js';
+export interface PartnerApiOptions {
+    /** Partner-Schluessel `pk_test_…` / `pk_live_…`. Gehoert auf einen Server. */
+    partnerKey: string;
+    /** Abweichende Basis-URL; Vorgabe `https://api.kasseneck.at/v1`. */
+    baseUrl?: string;
+    /** Zeitlimit je Aufruf in Millisekunden. */
+    timeoutMs?: number;
+    /** Eigene `fetch`-Umsetzung (Tests, Proxys). */
+    fetch?: FetchLike;
+}
+export interface PartnerApi {
+    getPartnerInfo(): Promise<PartnerInfo>;
+    createPartnerCustomer(optionen: CreateCustomerOptions): Promise<CreateCustomerResult>;
+    listPartnerCustomers(optionen?: ListCustomersOptions): Promise<KundenListe>;
+    getPartnerCustomer(customerId: string): Promise<Kunde>;
+    sendPartnerCustomerFonLink(customerId: string): Promise<FonLinkResult>;
+    requestCustomerSignature(customerId: string, optionen?: {
+        art?: string;
+        additional?: boolean;
+    }): Promise<RequestSignatureResult>;
+    getCustomerSignatureStatus(customerId: string): Promise<SignaturStand>;
+    createCustomerCashregister(optionen: CreateCashregisterOptions): Promise<CreateCashregisterResult>;
+    activateCashregister(customerId: string, cashregisterId: string): Promise<ActivateCashregisterResult>;
+    listCustomerCashregisters(customerId: string): Promise<KassenListe>;
+    /** Geheimnisse des Betriebs — siehe `getCustomerCredentials` in endpunkte.ts. */
+    getCustomerCredentials(customerId: string): Promise<CustomerCredentials>;
+    /**
+     * Ist diese Adresse als Kasseneck-Zugang noch frei? Nur noetig, wenn der
+     * Betrieb einen eigenen Login bekommen soll — sonst faellt `email_taken`
+     * erst nach dem ganzen Formular auf.
+     */
+    checkPartnerCustomerEmail(email: string): Promise<boolean>;
+    createPartnerWebhook(optionen: CreateWebhookOptions): Promise<CreateWebhookResult>;
+    listPartnerWebhooks(): Promise<WebhookListe>;
+    updatePartnerWebhook(webhookId: string, patch: WebhookPatch): Promise<PartnerWebhook>;
+    deletePartnerWebhook(webhookId: string): Promise<string>;
+    /**
+     * Neues Secret fuer denselben Endpunkt — dieselbe `webhookId`, dieselben
+     * Ereignisse. Das alte gilt ab der Antwort nicht mehr.
+     */
+    rotatePartnerWebhookSecret(webhookId: string): Promise<CreateWebhookResult>;
+    /**
+     * Eine Probe an einen Endpunkt — ohne `event` die Leitungsprobe
+     * `webhook.test`, mit `event` genau der Fall, den der Empfaenger behandeln
+     * soll. Jede Probe traegt `test: true` im Umschlag.
+     */
+    sendPartnerWebhookTest(webhookId: string, event?: PartnerWebhookEventType | (string & {})): Promise<WebhookTestResult>;
+    listPartnerWebhookDeliveries(optionen?: {
+        webhookId?: string;
+        limit?: number;
+    }): Promise<WebhookZustellung[]>;
+    /**
+     * Der Handlungssatz zu einem beliebigen Fehlercode der Partner-API. Gehoert
+     * in die eigene Fehlermeldung, damit ein Anwender nicht in der Doku
+     * nachschlagen muss.
+     */
+    fehlerRat(code: string): string | undefined;
+}
+export declare function createPartnerApi(optionen: PartnerApiOptions): PartnerApi;

package/dist/cjs/partner/api.js

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * Fassade ueber den Partner-Aufrufen: Schluessel einmal binden, dann rufen.
+ *
+ * Wie [createKasseneckApi] bewusst **keine** Klasse — die Aufrufe sind freie
+ * Funktionen und bleiben einzeln importierbar.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPartnerApi = createPartnerApi;
+const transport_js_1 = require("../client/transport.js");
+const auth_js_1 = require("./auth.js");
+const fehler_js_1 = require("./fehler.js");
+const endpunkte_js_1 = require("./endpunkte.js");
+const webhooks_js_1 = require("./webhooks.js");
+function createPartnerApi(optionen) {
+    const rufen = (0, transport_js_1.createTransport)({
+        auth: (0, auth_js_1.partnerKeyAuth)({ partnerKey: optionen.partnerKey }),
+        baseUrl: optionen.baseUrl,
+        timeoutMs: optionen.timeoutMs,
+        fetch: optionen.fetch,
+    });
+    return {
+        getPartnerInfo: () => (0, endpunkte_js_1.getPartnerInfo)(rufen),
+        createPartnerCustomer: (o) => (0, endpunkte_js_1.createPartnerCustomer)(rufen, o),
+        listPartnerCustomers: (o) => (0, endpunkte_js_1.listPartnerCustomers)(rufen, o),
+        getPartnerCustomer: (id) => (0, endpunkte_js_1.getPartnerCustomer)(rufen, id),
+        sendPartnerCustomerFonLink: (id) => (0, endpunkte_js_1.sendPartnerCustomerFonLink)(rufen, id),
+        requestCustomerSignature: (id, o) => (0, endpunkte_js_1.requestCustomerSignature)(rufen, id, o),
+        getCustomerSignatureStatus: (id) => (0, endpunkte_js_1.getCustomerSignatureStatus)(rufen, id),
+        createCustomerCashregister: (o) => (0, endpunkte_js_1.createCustomerCashregister)(rufen, o),
+        activateCashregister: (kunde, kasse) => (0, endpunkte_js_1.activateCashregister)(rufen, kunde, kasse),
+        listCustomerCashregisters: (id) => (0, endpunkte_js_1.listCustomerCashregisters)(rufen, id),
+        getCustomerCredentials: (id) => (0, endpunkte_js_1.getCustomerCredentials)(rufen, id),
+        checkPartnerCustomerEmail: (email) => (0, endpunkte_js_1.checkPartnerCustomerEmail)(rufen, email),
+        createPartnerWebhook: (o) => (0, webhooks_js_1.createPartnerWebhook)(rufen, o),
+        listPartnerWebhooks: () => (0, webhooks_js_1.listPartnerWebhooks)(rufen),
+        updatePartnerWebhook: (id, patch) => (0, webhooks_js_1.updatePartnerWebhook)(rufen, id, patch),
+        deletePartnerWebhook: (id) => (0, webhooks_js_1.deletePartnerWebhook)(rufen, id),
+        rotatePartnerWebhookSecret: (id) => (0, webhooks_js_1.rotatePartnerWebhookSecret)(rufen, id),
+        sendPartnerWebhookTest: (id, event) => (0, webhooks_js_1.sendPartnerWebhookTest)(rufen, id, event),
+        listPartnerWebhookDeliveries: (o) => (0, webhooks_js_1.listPartnerWebhookDeliveries)(rufen, o),
+        fehlerRat: (code) => (0, fehler_js_1.partnerFehlerRat)(code),
+    };
+}

package/dist/cjs/partner/auth.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Anmeldung eines Partner-Servers: der Partner-Schluessel als Bearer.
+ *
+ * Ein dritter Weg neben `apiKeyAuth` (Geraete) und `registerUserAuth`
+ * (Browser-Kasse) — und der einzige, mit dem die Partner-Endpunkte antworten.
+ * Er traegt **keine** Kopfzeile `cashregister-token`: ein Partner arbeitet nie
+ * an einer Kasse, sondern ueber Betriebe.
+ *
+ * **Der Schluessel gehoert auf einen Server.** Er kann Betriebe anlegen und —
+ * mit `credentials:read` — deren Geheimnisse holen. In einer Browser- oder
+ * Mobil-App ist er ausgeliefert, nicht hinterlegt.
+ */
+import type { KasseneckAuth } from '../client/auth.js';
+import type { PartnerEnv } from './typen.js';
+/**
+ * Die Umgebung eines Partner-Schluessels, ohne Netzaufruf — `null`, wenn es
+ * keiner ist. Nuetzlich fuer die Zusicherung „auf diesem Server laeuft nur
+ * `pk_live_`" beim Hochfahren.
+ */
+export declare function partnerKeyEnv(schluessel: string): PartnerEnv | null;
+export interface PartnerKeyAuthOptions {
+    /** Partner-Schluessel `pk_test_…` / `pk_live_…`. */
+    partnerKey: string;
+}
+/**
+ * Anmeldung per Partner-Schluessel.
+ *
+ * Die Form wird hier geprueft und nicht erst vom Server: ein vertauschter
+ * `kr_live_`-Schluessel (der eines Betriebs) faellt sonst als nichtssagendes
+ * „ungueltiger Schluessel" auf, obwohl er tadellos ist — nur eben fuer einen
+ * anderen Weg. Die Meldung nennt nie den Wert, nur seine Art.
+ */
+export declare function partnerKeyAuth(options: PartnerKeyAuthOptions): KasseneckAuth;

package/dist/cjs/partner/auth.js

@@ -0,0 +1,52 @@
+"use strict";
+/**
+ * Anmeldung eines Partner-Servers: der Partner-Schluessel als Bearer.
+ *
+ * Ein dritter Weg neben `apiKeyAuth` (Geraete) und `registerUserAuth`
+ * (Browser-Kasse) — und der einzige, mit dem die Partner-Endpunkte antworten.
+ * Er traegt **keine** Kopfzeile `cashregister-token`: ein Partner arbeitet nie
+ * an einer Kasse, sondern ueber Betriebe.
+ *
+ * **Der Schluessel gehoert auf einen Server.** Er kann Betriebe anlegen und —
+ * mit `credentials:read` — deren Geheimnisse holen. In einer Browser- oder
+ * Mobil-App ist er ausgeliefert, nicht hinterlegt.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.partnerKeyEnv = partnerKeyEnv;
+exports.partnerKeyAuth = partnerKeyAuth;
+const errors_js_1 = require("../client/errors.js");
+/**
+ * Form eines Partner-Schluessels: `pk_test_…` bzw. `pk_live_…`. Der Rest ist
+ * opak — die Laenge kann sich aendern, das Praefix nicht (an ihm haengt die
+ * Umgebung).
+ */
+const SCHLUESSEL_FORM = /^pk_(test|live)_[A-Za-z0-9_-]{16,}$/;
+/**
+ * Die Umgebung eines Partner-Schluessels, ohne Netzaufruf — `null`, wenn es
+ * keiner ist. Nuetzlich fuer die Zusicherung „auf diesem Server laeuft nur
+ * `pk_live_`" beim Hochfahren.
+ */
+function partnerKeyEnv(schluessel) {
+    const treffer = SCHLUESSEL_FORM.exec(typeof schluessel === 'string' ? schluessel.trim() : '');
+    return treffer ? treffer[1] : null;
+}
+/**
+ * Anmeldung per Partner-Schluessel.
+ *
+ * Die Form wird hier geprueft und nicht erst vom Server: ein vertauschter
+ * `kr_live_`-Schluessel (der eines Betriebs) faellt sonst als nichtssagendes
+ * „ungueltiger Schluessel" auf, obwohl er tadellos ist — nur eben fuer einen
+ * anderen Weg. Die Meldung nennt nie den Wert, nur seine Art.
+ */
+function partnerKeyAuth(options) {
+    const schluessel = typeof options?.partnerKey === 'string' ? options.partnerKey.trim() : '';
+    if (!schluessel) {
+        throw new errors_js_1.KasseneckAuthError('partnerKeyAuth: partnerKey fehlt');
+    }
+    if (!partnerKeyEnv(schluessel)) {
+        throw new errors_js_1.KasseneckAuthError('partnerKeyAuth: partnerKey hat nicht die Form pk_test_… / pk_live_… — ein Betriebsschluessel (kr_…) passt hier nicht');
+    }
+    // Pro Aufruf ein frisches Objekt: der Transport darf daran schreiben, ohne
+    // die naechste Anfrage zu vergiften (wie apiKeyAuth).
+    return () => ({ headers: { Authorization: `Bearer ${schluessel}` }, params: {} });
+}

package/dist/cjs/partner/betrieb.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Was ein Betrieb ueber die Schnittstelle mitbringen darf — Feld fuer Feld.
+ *
+ * **Unbekannte Felder werden abgewiesen, nicht stillschweigend verworfen.**
+ * Vorher verschwand ein `iban` oder ein vertippter Feldname spurlos: der
+ * Partner glaubte, er habe die Steuernummer geschickt, und Kasseneck hatte
+ * nichts. Ein Feld, das man schickt und das nichts bewirkt, ist der teuerste
+ * Fehler in einer Schnittstelle, weil ihn niemand bemerkt.
+ *
+ * Seitdem antwortet `createPartnerCustomer` mit `validation` und dem genauen
+ * Feldpfad — verschachtelt und je Kontakt: `address.land`,
+ * `tax_details.ustid`, `contacts.1.abteilung`.
+ *
+ * Zwei Dinge halten diese Seite dagegen:
+ *
+ * - der Typ [Betrieb] (typen.ts) hat genau diese Felder, und TypeScript meldet
+ *   ein ueberzaehliges schon beim Tippen;
+ * - [unbekannteBetriebsfelder] beantwortet dieselbe Frage zur Laufzeit — fuer
+ *   Daten, die aus einer Datenbank oder einem Formular kommen und deshalb nie
+ *   durch die Typpruefung gelaufen sind.
+ *
+ * **Die Wahrheit bleibt der Server.** Dieser Client weist nichts von sich aus
+ * ab: eine spaetere Backend-Fassung darf ein Feld ergaenzen, ohne dass ein
+ * aelterer Client es blockiert. [unbekannteBetriebsfelder] ist die Vorschau,
+ * nicht das Tor.
+ *
+ * Quelle der Liste: `partner-core.BETRIEB_FELDER` im Backend.
+ */
+/**
+ * Jedes erlaubte Feld als Pfad. `[]` markiert eine Liste — im Fehlerpfad des
+ * Servers steht dort der Index (`contacts.0.name`).
+ *
+ * Bewusst flach und nicht verschachtelt: so ist es EINE Liste, die der
+ * Zwilling Zeile fuer Zeile nachhalten kann. Das Schema fuer die Pruefung
+ * entsteht daraus (siehe unten) und nicht daneben.
+ */
+export declare const BETRIEB_FELDER: readonly ["companyName", "legalForm", "state", "industry", "companyRegister", "court", "web", "phone", "email", "billingEmail", "address.street", "address.number", "address.zip", "address.city", "taxDetails.taxNumber", "taxDetails.vatId", "taxDetails.gln", "taxDetails.smallBusiness", "contacts[].name", "contacts[].email", "contacts[].phone", "contacts[].roles", "taxAdvisor.name", "taxAdvisor.email", "taxAdvisor.phone", "taxAdvisor.mayContact"];
+export type BetriebFeld = typeof BETRIEB_FELDER[number];
+/**
+ * Die Feldpfade eines Betriebs, die [BETRIEB_FELDER] nicht kennt — dieselbe
+ * Ableitung wie im Backend, also dieselben Pfade wie in `data.errors[].field`.
+ * Leer heisst: aus dieser Sicht ist nichts ueberzaehlig.
+ *
+ * Sagt **nichts** ueber die Werte: Steuernummer, UID, PLZ und Gericht prueft
+ * das Backend mit `@kreiseck/validator`. Diese Funktion beantwortet nur die
+ * Frage „schicke ich etwas, das dort niemand erwartet?".
+ */
+export declare function unbekannteBetriebsfelder(business: unknown): string[];

package/dist/cjs/partner/betrieb.js

@@ -0,0 +1,136 @@
+"use strict";
+/**
+ * Was ein Betrieb ueber die Schnittstelle mitbringen darf — Feld fuer Feld.
+ *
+ * **Unbekannte Felder werden abgewiesen, nicht stillschweigend verworfen.**
+ * Vorher verschwand ein `iban` oder ein vertippter Feldname spurlos: der
+ * Partner glaubte, er habe die Steuernummer geschickt, und Kasseneck hatte
+ * nichts. Ein Feld, das man schickt und das nichts bewirkt, ist der teuerste
+ * Fehler in einer Schnittstelle, weil ihn niemand bemerkt.
+ *
+ * Seitdem antwortet `createPartnerCustomer` mit `validation` und dem genauen
+ * Feldpfad — verschachtelt und je Kontakt: `address.land`,
+ * `tax_details.ustid`, `contacts.1.abteilung`.
+ *
+ * Zwei Dinge halten diese Seite dagegen:
+ *
+ * - der Typ [Betrieb] (typen.ts) hat genau diese Felder, und TypeScript meldet
+ *   ein ueberzaehliges schon beim Tippen;
+ * - [unbekannteBetriebsfelder] beantwortet dieselbe Frage zur Laufzeit — fuer
+ *   Daten, die aus einer Datenbank oder einem Formular kommen und deshalb nie
+ *   durch die Typpruefung gelaufen sind.
+ *
+ * **Die Wahrheit bleibt der Server.** Dieser Client weist nichts von sich aus
+ * ab: eine spaetere Backend-Fassung darf ein Feld ergaenzen, ohne dass ein
+ * aelterer Client es blockiert. [unbekannteBetriebsfelder] ist die Vorschau,
+ * nicht das Tor.
+ *
+ * Quelle der Liste: `partner-core.BETRIEB_FELDER` im Backend.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BETRIEB_FELDER = void 0;
+exports.unbekannteBetriebsfelder = unbekannteBetriebsfelder;
+/**
+ * Jedes erlaubte Feld als Pfad. `[]` markiert eine Liste — im Fehlerpfad des
+ * Servers steht dort der Index (`contacts.0.name`).
+ *
+ * Bewusst flach und nicht verschachtelt: so ist es EINE Liste, die der
+ * Zwilling Zeile fuer Zeile nachhalten kann. Das Schema fuer die Pruefung
+ * entsteht daraus (siehe unten) und nicht daneben.
+ */
+exports.BETRIEB_FELDER = [
+    'companyName',
+    'legalForm',
+    'state',
+    'industry',
+    'companyRegister',
+    'court',
+    'web',
+    'phone',
+    'email',
+    'billingEmail',
+    'address.street',
+    'address.number',
+    'address.zip',
+    'address.city',
+    'taxDetails.taxNumber',
+    'taxDetails.vatId',
+    'taxDetails.gln',
+    'taxDetails.smallBusiness',
+    'contacts[].name',
+    'contacts[].email',
+    'contacts[].phone',
+    'contacts[].roles',
+    'taxAdvisor.name',
+    'taxAdvisor.email',
+    'taxAdvisor.phone',
+    'taxAdvisor.mayContact',
+];
+/** Das Schema entsteht aus [BETRIEB_FELDER] — eine Quelle, keine zweite Liste. */
+const SCHEMA = (() => {
+    const wurzel = {};
+    for (const pfad of exports.BETRIEB_FELDER) {
+        const teile = pfad.split('.');
+        let stand = wurzel;
+        teile.forEach((rohes, i) => {
+            const liste = rohes.endsWith('[]');
+            const name = liste ? rohes.slice(0, -2) : rohes;
+            if (i === teile.length - 1) {
+                stand[name] = true;
+                return;
+            }
+            if (liste) {
+                const vorhanden = stand[name];
+                const eintrag = Array.isArray(vorhanden) ? vorhanden[0] : {};
+                stand[name] = [eintrag];
+                stand = eintrag;
+                return;
+            }
+            const vorhanden = stand[name];
+            const unter = vorhanden !== undefined && vorhanden !== true && !Array.isArray(vorhanden) ? vorhanden : {};
+            stand[name] = unter;
+            stand = unter;
+        });
+    }
+    return wurzel;
+})();
+function istObjekt(wert) {
+    return wert !== null && typeof wert === 'object' && !Array.isArray(wert);
+}
+function sammle(eingabe, schema, pfad) {
+    if (!istObjekt(eingabe))
+        return [];
+    const raus = [];
+    for (const [name, wert] of Object.entries(eingabe)) {
+        const voll = pfad ? `${pfad}.${name}` : name;
+        const erlaubt = schema[name];
+        if (erlaubt === undefined) {
+            raus.push(voll);
+            continue;
+        }
+        if (erlaubt === true)
+            continue;
+        if (Array.isArray(erlaubt)) {
+            // Ein falscher Typ ist kein unbekanntes Feld — den meldet der Server als
+            // eigenen Formfehler auf demselben Pfad.
+            if (!Array.isArray(wert))
+                continue;
+            wert.forEach((eintrag, idx) => raus.push(...sammle(eintrag, erlaubt[0], `${voll}.${idx}`)));
+            continue;
+        }
+        raus.push(...sammle(wert, erlaubt, voll));
+    }
+    return raus;
+}
+/**
+ * Die Feldpfade eines Betriebs, die [BETRIEB_FELDER] nicht kennt — dieselbe
+ * Ableitung wie im Backend, also dieselben Pfade wie in `data.errors[].field`.
+ * Leer heisst: aus dieser Sicht ist nichts ueberzaehlig.
+ *
+ * Sagt **nichts** ueber die Werte: Steuernummer, UID, PLZ und Gericht prueft
+ * das Backend mit `@kreiseck/validator`. Diese Funktion beantwortet nur die
+ * Frage „schicke ich etwas, das dort niemand erwartet?".
+ */
+function unbekannteBetriebsfelder(business) {
+    return sammle(business, SCHEMA, '');
+}