@orvello/sdk 0.1.0 → 0.2.1

package/dist/index.d.ts

@@ -83,6 +83,269 @@ declare function formatAmount(amount: number | string, currency?: string, locale
  */
 declare function mapPaymentAccountToBankDetails(account: PaymentAccount): BankAccountDetails;
 
+type RouteChannelCode = "b" | "k" | "n";
+type RouteIndexEntry = readonly [
+    method: string,
+    path: string,
+    channel: RouteChannelCode,
+    authType: string,
+    validated: number,
+    scopes?: readonly string[]
+];
+declare const ROUTE_INDEX: Readonly<Record<string, RouteIndexEntry>>;
+
+/**
+ * Die Route entscheidet, welches Credential mitgeht — nicht der Aufrufer.
+ *
+ * orvello (node-bill) kennt zwei Bahnen nebeneinander, und sie sind nicht
+ * austauschbar:
+ *
+ * - **bearer** — die Geschaeftsrouten (`unified_bearer`, `frontend_*`). Hier gilt
+ *   ein OAuth2-Client (client_credentials) oder ein als Bearer gesendeter Token.
+ *   Das Credential gehoert der *rufenden App*.
+ * - **api_key** — die Verwaltungsrouten (`x_api_key_https`), also alles unter
+ *   `/oauth/clients/external/*`. Hier gilt der Header `x-api-key`. Das Credential
+ *   gehoert der *Kante* zwischen Verwalter und Dienst.
+ *
+ * Bis 0.1.0 schickte der Client alles als `Authorization: Bearer`. Die neun
+ * Verwaltungsrouten waren damit zwar getippt und aufrufbar, aber grundsaetzlich
+ * nicht authentisierbar — ein Loch, das erst beim ersten echten Aufruf sichtbar
+ * geworden waere, und dann als `403 Forbidden: Invalid API key` ohne Hinweis auf
+ * die Ursache.
+ *
+ * Der generierte Vertrag traegt `auth.type` an jeder einzelnen Route. Diese Datei
+ * liest genau das aus und macht es zur Laufzeitentscheidung. Eine neue Route mit
+ * einer neuen Auth-Art faellt damit nicht still in die falsche Bahn, sondern
+ * kommt hier an.
+ */
+
+/** Welche Kopfzeile eine Route verlangt. */
+type OrvelloAuthChannel = "bearer" | "api_key" | "none";
+type OrvelloOperationId = keyof typeof ROUTE_INDEX & string;
+type OrvelloOperation = {
+    operationId: string;
+    method: string;
+    /** Die Vorlage aus dem Vertrag, Platzhalter noch als `:name`. */
+    path: string;
+    /** Die Auth-Art, wie sie woertlich im Vertrag steht. */
+    authType: string;
+    /** Was daraus fuer den Aufruf folgt. */
+    channel: OrvelloAuthChannel;
+    /** Was der Dienst an dieser Route validiert — aus `meta.validated`. */
+    validated: {
+        params: boolean;
+        query: boolean;
+        body: boolean;
+    };
+    /** Die im Vertrag geforderten OAuth2-Scopes, sofern die Auth-Art welche nennt. */
+    scopes: readonly string[];
+};
+/**
+ * Bildet eine Auth-Art des Vertrags auf die Bahn ab, ueber die sie bedient wird.
+ *
+ * Unbekannte Arten landen bewusst auf `bearer`: das ist die Bahn aller
+ * Geschaeftsrouten und damit die einzige Voreinstellung, die einen neuen,
+ * hier noch nicht gesehenen Routentyp nicht sofort unbrauchbar macht.
+ */
+declare function authChannelForContractType(authType: string | undefined | null): OrvelloAuthChannel;
+/** Alle Operationen des Vertrags, gegen den dieses SDK gebaut wurde. */
+declare function listOperations(): readonly OrvelloOperation[];
+/** Eine Operation nach ihrer `operationId`, oder `null`, wenn der Vertrag sie nicht kennt. */
+declare function describeOperation(operationId: string): OrvelloOperation | null;
+/**
+ * Findet die Route, die ein konkreter Pfad anspricht.
+ *
+ * ⭐ Woertliche Segmente schlagen Platzhalter. Ohne diese Regel wuerde
+ * `GET /oauth/clients/external/list` auf `/oauth/clients/external/:idOrClientId`
+ * fallen — beide sind GET mit vier Segmenten — und die Auflistung bekaeme die
+ * Auth-Entscheidung einer anderen Route. Dass beide hier dieselbe Bahn
+ * verlangen, ist Zufall und kein Verlass.
+ */
+declare function resolveOperation(method: string, path: string): OrvelloOperation | null;
+/** Fehlt ein Pfad-Parameter, ist der Aufruf falsch — nicht der Dienst. */
+declare class OrvelloOperationError extends Error {
+    readonly operationId: string;
+    constructor(message: string, operationId: string);
+}
+/**
+ * Setzt die Platzhalter einer Vertrags-Route.
+ *
+ * Ein fehlender Parameter wirft hier, statt einen Pfad mit `:idOrClientId` darin
+ * ans Netz zu geben. Der Dienst antwortete darauf mit 404 oder — schlimmer — mit
+ * dem Treffer einer anderen Route.
+ */
+declare function buildPath(operationId: string, params?: Record<string, unknown>): string;
+
+/**
+ * Was dieser Dienst kann — als Daten, ohne Netz und ohne Vermutung.
+ *
+ * Ein Verbindungs-Verwalter (node-amp) kann Kanten nur dann selbst herstellen,
+ * pruefen und reparieren, wenn er weiss, *was die Gegenseite ueberhaupt anbietet*.
+ * Bis hierher war das Wissen implizit: irgendwo im Verwalter stand fest
+ * einprogrammiert, dass orvello Clients ausstellen kann. Wird eine Faehigkeit dort
+ * angenommen und fehlt sie hier, ist das Ergebnis eine Zeile, die gesund aussieht,
+ * weil nie jemand gefragt hat.
+ *
+ * Deshalb leitet sich der Bericht ausschliesslich aus dem mitgelieferten Vertrag
+ * ab: eine Faehigkeit gilt genau dann als vorhanden, wenn die zugehoerige
+ * Operation im Vertrag steht. Faellt sie in node-bill weg, verschwindet sie beim
+ * naechsten `sync:contract` auch hier — niemand muss daran denken.
+ *
+ * ⚠ Der Bericht sagt, was der Vertrag hergibt, nicht was der Aufrufer darf. Ob ein
+ * Credential wirklich traegt, beantwortet allein {@link preflightOrvello}.
+ */
+
+/**
+ * Eine Faehigkeit und die Operationen, an denen sie haengt.
+ *
+ * `operations` ist der Beleg: wer die Angabe anzweifelt, kann sie gegen den
+ * Vertrag nachschlagen, statt dem Wort zu glauben.
+ */
+type OrvelloCapability = {
+    supported: boolean;
+    operations: string[];
+    /** Warum nicht — nur gesetzt, wenn `supported` falsch ist. */
+    reason?: string;
+};
+type OrvelloCapabilities = {
+    service: "orvello";
+    sdkVersion: string;
+    contractSha256: string;
+    /** Wie viele Operationen der Vertrag insgesamt kennt. */
+    operationCount: number;
+    /** Welche Credential-Bahnen der Vertrag ueberhaupt verlangt. */
+    authChannels: Record<OrvelloAuthChannel, number>;
+    capabilities: {
+        /** Der Dienst nennt seinen eigenen Vertrags-Fingerabdruck (`GET /health/contract`). */
+        contractFingerprint: OrvelloCapability;
+        /** Ein unauthentisierter Erreichbarkeits-Endpunkt. */
+        healthCheck: OrvelloCapability;
+        /** OAuth2-Clients fuer andere Apps anlegen, lesen, aendern, loeschen. */
+        clientManagement: OrvelloCapability;
+        /** Client-Geheimnis erneuern. */
+        clientRotation: OrvelloCapability;
+        /**
+         * Gnadenfrist beim Wechsel: das alte Geheimnis bleibt gueltig, bis es
+         * ausdruecklich zurueckgezogen wird — und laesst sich zurueckdrehen.
+         */
+        rotationGracePeriod: OrvelloCapability;
+        /** Zugang sofort entziehen. */
+        clientRevocation: OrvelloCapability;
+        /** Berechtigungen (entitlements) lesen und setzen. */
+        entitlements: OrvelloCapability;
+        /** Rechnungen ueber die externe API. */
+        invoicing: OrvelloCapability;
+        /**
+         * Ein serverseitiger Probelauf, der schreibt *als ob*, aber nichts aendert.
+         *
+         * ⭐ Steht hier bewusst mit dem Grund statt still auf `false`: orvello kennt
+         * `dryRun` heute nur in der Buchhaltung, nicht in der Client-Verwaltung. Ein
+         * Verwalter, der einen Probelauf braucht, nimmt {@link preflightOrvello} —
+         * der ist nebenwirkungsfrei, aber er beweist die Berechtigung, nicht das
+         * Ergebnis. Der Unterschied gehoert benannt, nicht verschwiegen.
+         */
+        serverSideDryRun: OrvelloCapability;
+    };
+};
+/**
+ * Der Faehigkeitsbericht dieses Dienstes. Rein aus dem Vertrag, kein Netzzugriff,
+ * kein Credential noetig — damit ein Verwalter ihn auch dann fuehren kann, wenn
+ * die Verbindung gerade nicht steht.
+ */
+declare function orvelloCapabilities(): OrvelloCapabilities;
+
+/**
+ * Der Probelauf: "wuerde dieser Aufruf heute klappen?" — ohne ihn zu tun.
+ *
+ * Ein Verbindungs-Verwalter muss zwei Dinge auseinanderhalten koennen, die sonst
+ * gern zusammenfallen: *darf ich* und *habe ich*. Eine Kante anzulegen erzeugt
+ * echte Daten auf beiden Seiten; das ist ein freigegebener Schritt und kein
+ * Nebenprodukt einer Pruefung. Trotzdem will man jederzeit — auch turnusmaessig,
+ * auch ohne Anlass — wissen, ob der Weg noch traegt.
+ *
+ * Genau diese Luecke fuellt der Probelauf. Er geht denselben Weg wie der echte
+ * Aufruf: dieselbe Basis-URL, dieselbe Credential-Bahn, derselbe Vertrag. Er
+ * hoert nur vor dem Schreiben auf. Was er beweist, ist die **Berechtigung**, nicht
+ * das **Ergebnis** — und dieser Unterschied steht in jedem Bericht, damit ihn
+ * niemand ueberliest.
+ *
+ * ⭐ Jeder Schritt traegt seinen Grund. Ein `ok: false` ohne Satz ist genau die
+ * schweigende Luecke, die aussieht wie Gesundheit.
+ */
+
+/** Der oeffentliche Erreichbarkeits-Endpunkt, wie ihn der Vertrag fuehrt. */
+declare const HEALTH_PATH: string;
+type PreflightStepName = "operation" | "path-parameters" | "request-shape" | "reachable" | "contract" | "credential-configured" | "credential-accepted";
+type PreflightStep = {
+    name: PreflightStepName;
+    ok: boolean;
+    /** Uebersprungen heisst: nicht gepruefft. Nie "in Ordnung". */
+    skipped: boolean;
+    /** Was geprueft wurde und was dabei herauskam — in Worten, nicht als Code. */
+    detail: string;
+};
+type PreflightReport = {
+    ok: boolean;
+    operationId: string;
+    method: string | null;
+    /** Der Pfad, der wirklich gerufen wuerde — Platzhalter bereits gesetzt. */
+    path: string | null;
+    baseUrl: string | null;
+    authChannel: OrvelloAuthChannel | null;
+    /**
+     * Immer `"none"`. Ein Probelauf schreibt nicht — das ist seine Zusage, nicht
+     * eine Eigenschaft des Einzelfalls.
+     */
+    sideEffects: "none";
+    /**
+     * Ob der Dienst selbst einen serverseitigen Probelauf dieser Operation kennt.
+     * `false` heisst: das hier ist eine Wegpruefung, keine Ergebnisvorschau.
+     */
+    serverSideDryRun: boolean;
+    steps: PreflightStep[];
+    problems: string[];
+    checkedAt: string;
+};
+/**
+ * Was der Probelauf vom Client braucht. Bewusst schmal gehalten, damit die
+ * Pruefung nicht am Client haengt und einzeln testbar bleibt.
+ */
+type PreflightHost = {
+    resolveBaseUrl(): Promise<string>;
+    fetchImpl(): typeof globalThis.fetch;
+    /** Ist fuer diese Bahn ueberhaupt ein Credential hinterlegt? Ohne Netz. */
+    hasCredentialFor(channel: OrvelloAuthChannel): Promise<boolean>;
+    /**
+     * Ein echter, ausschliesslich lesender Aufruf auf derselben Bahn.
+     * Beweist, dass das Credential nicht nur da ist, sondern auch angenommen wird.
+     */
+    probeCredential(channel: OrvelloAuthChannel, signal?: AbortSignal): Promise<{
+        ok: boolean;
+        detail: string;
+    }>;
+};
+type PreflightOptions = {
+    params?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    body?: unknown;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    /**
+     * Den teuersten Schritt auslassen: kein echter Aufruf, nur die Frage, ob ein
+     * Credential hinterlegt ist. Fuer Massenpruefungen ueber viele Kanten.
+     */
+    skipCredentialProbe?: boolean;
+};
+/**
+ * Prueft einen Aufrufweg, ohne ihn zu gehen.
+ *
+ * Die Reihenfolge ist Absicht: erst alles, was ohne Netz entschieden werden kann
+ * (Vertrag, Parameter, Gestalt), dann die Erreichbarkeit, dann der Vertrag der
+ * laufenden Gegenstelle, zuletzt das Credential. So nennt der Bericht bei einem
+ * Fehlschlag die *frueheste* Ursache, statt einen Folgefehler zu melden.
+ */
+declare function preflightOrvello(host: PreflightHost, operationId: string, options?: PreflightOptions): Promise<PreflightReport>;
+
 type AuthProvider = string | (() => string | Promise<string>) | {
     apiKey: string;
 } | {
@@ -91,6 +354,15 @@ type AuthProvider = string | (() => string | Promise<string>) | {
     scope?: string;
     tokenUrl?: string;
 };
+/** Ein Wert, der sich auch erst beim Aufruf ergeben darf. */
+type ValueProvider<T> = T | (() => T | Promise<T>);
+type HeadersProvider = ValueProvider<Record<string, string>>;
+interface CircuitBreakerConfig {
+    /** Wie viele Fehlschlaege in Folge den Kreis oeffnen. */
+    threshold?: number;
+    /** Wie lange danach nicht erneut versucht wird, bevor ein Versuch den Kreis prueft. */
+    cooldownMs?: number;
+}
 interface OrvelloClientConfig {
     /**
      * Base URL of the orvello accounting/invoicing service this client talks to.
@@ -101,11 +373,44 @@ interface OrvelloClientConfig {
      * throws rather than silently aiming at a fixed host.
      */
     baseUrl?: BaseUrlProvider;
+    /**
+     * Das Credential der **Geschaeftsrouten** — ein OAuth2-Client
+     * (client_credentials) oder ein fertiger Token. Geht als
+     * `Authorization: Bearer` mit. Env: `ORVELLO_OAUTH_CLIENT_ID` /
+     * `ORVELLO_OAUTH_CLIENT_SECRET` / `ORVELLO_OAUTH_SCOPE`, ersatzweise
+     * `ORVELLO_API_KEY`.
+     */
     auth?: AuthProvider;
+    /**
+     * Das Credential der **Verwaltungsrouten** (`/oauth/clients/external/*`), also
+     * der Header `x-api-key`. Env: `ORVELLO_MANAGEMENT_API_KEY`.
+     *
+     * ⭐ Das ist bewusst ein zweiter, eigener Wert und keine zweite Schreibweise
+     * desselben. Die Geschaeftsrouten gehoeren der rufenden App, die
+     * Verwaltungsrouten der Kante zwischen Verwalter und Dienst — wer beides in ein
+     * Feld legt, verliert genau die Trennung, die eine Rotation je Kante moeglich
+     * macht. Ein Client, der nur Rechnungen schreibt, laesst diesen Wert weg und
+     * kann dann auch keine Zugaenge ausstellen. Das ist erwuenscht.
+     */
+    managementApiKey?: ValueProvider<string>;
+    /**
+     * Zusaetzliche Kopfzeilen fuer jede Anfrage. Wird vor der Auth-Kopfzeile
+     * angewandt, kann sie also nicht versehentlich ueberschreiben.
+     */
+    headers?: HeadersProvider;
     fetch?: typeof globalThis.fetch;
     timeoutMs?: number;
     maxRetries?: number;
     retryBaseDelayMs?: number;
+    /**
+     * Der Sicherungsautomat. `false` schaltet ihn ab.
+     *
+     * Wiederholungen helfen gegen einen Aussetzer; sie helfen nicht, wenn die
+     * Gegenstelle weg ist — dann verlaengern sie nur jede einzelne Anfrage um das
+     * volle Zeitlimit mal Versuche. Der Automat beendet diesen Zustand schnell und
+     * laut, statt langsam und leise.
+     */
+    circuitBreaker?: CircuitBreakerConfig | false;
 }
 interface RequestOptions {
     query?: Record<string, unknown>;
@@ -115,7 +420,36 @@ interface RequestOptions {
     timeoutMs?: number;
     maxRetries?: number;
     signal?: AbortSignal;
+    /**
+     * Die Credential-Bahn ausdruecklich setzen. Normalerweise unnoetig: der Client
+     * liest sie aus dem Vertrag der angesprochenen Route. Nur fuer Pfade gedacht,
+     * die der mitgelieferte Vertrag (noch) nicht kennt.
+     */
+    authChannel?: OrvelloAuthChannel;
 }
+/** Wie {@link RequestOptions}, aber fuer den Aufruf ueber eine `operationId`. */
+interface CallOptions extends RequestOptions {
+    params?: Record<string, unknown>;
+    body?: unknown;
+}
+type OrvelloHealth = {
+    /** Antwortet der Dienst ueberhaupt? */
+    available: boolean;
+    responseTimeMs: number;
+    /**
+     * Wurde ein Credential wirklich angenommen? `null` heisst: nicht geprueft,
+     * weil keines hinterlegt ist — nie "in Ordnung".
+     */
+    authenticated: boolean | null;
+    error?: string;
+};
+type CircuitBreakerState = {
+    open: boolean;
+    consecutiveFailures: number;
+    lastFailureAt: number | null;
+    threshold: number;
+    cooldownMs: number;
+};
 declare class OrvelloApiError extends Error {
     readonly status: number;
     readonly statusText: string;
@@ -130,20 +464,103 @@ declare class OrvelloApiError extends Error {
 declare class OrvelloClient {
     readonly baseUrl: BaseUrlProvider;
     private readonly auth?;
+    private readonly managementApiKey?;
+    private readonly extraHeaders?;
     private readonly doFetch;
     private readonly timeoutMs;
     private readonly maxRetries;
     private readonly retryBaseDelayMs;
     private cachedOAuthToken;
+    private readonly breakerThreshold;
+    private readonly breakerCooldownMs;
+    private breakerFailures;
+    private breakerLastFailureAt;
     private _bankAccountCache;
     private _bankAccountCacheTime;
     constructor(config?: OrvelloClientConfig);
     private envBaseUrl;
     private envAuth;
+    private envManagementApiKey;
     resolveBaseUrl(): Promise<string>;
+    private static resolveValue;
+    /**
+     * Der Verwaltungs-Schluessel, sofern hinterlegt.
+     *
+     * Ein leerer String zaehlt als "nicht hinterlegt". Sonst waere die haeufigste
+     * Fehlkonfiguration — eine gesetzte, aber leere Umgebungsvariable — von einem
+     * echten Wert nicht zu unterscheiden, und der Fehler kaeme erst als `403` vom
+     * Dienst zurueck.
+     */
+    private resolveManagementApiKey;
     private getAuthHeader;
     private isRetriable;
     request<T = unknown>(path: string, options?: RequestInit & RequestOptions): Promise<T>;
+    private recordSuccess;
+    private recordFailure;
+    /**
+     * Ist der Dienst nach aktuellem Wissen ansprechbar?
+     *
+     * Antwortet ohne Netzzugriff aus dem Zustand des Automaten. Nach Ablauf der
+     * Abkuehlzeit gilt er wieder als ansprechbar — der naechste echte Aufruf
+     * entscheidet dann, ob das stimmt.
+     */
+    isAvailable(): boolean;
+    /** Der Zustand des Automaten, unverfaelscht — fuer Diagnose-Oberflaechen. */
+    circuitState(): CircuitBreakerState;
+    /** Den Automaten von Hand schliessen, etwa nach einer behobenen Stoerung. */
+    resetCircuit(): void;
+    private assertCircuitClosed;
+    /**
+     * Eine Operation des Vertrags ueber ihre `operationId` aufrufen.
+     *
+     * Methode, Pfad und Credential-Bahn kommen aus dem Vertrag; der Aufrufer gibt
+     * nur die Werte. Das ist der Weg fuer alles, wofuer es keine getippte Methode
+     * gibt — und der Weg, der bei einer neuen Route sofort mitwaechst, statt auf
+     * eine Handarbeit in diesem Client zu warten.
+     *
+     * Der Rueckgabetyp ist bewusst offen: die genauen Typen je Operation stehen im
+     * Unterpfad `@orvello/sdk/contract` und werden hier als Typ-Argument gesetzt.
+     * Ein `operationId`, den der Vertrag nicht kennt, wirft sofort — nicht erst,
+     * wenn der Dienst mit 404 antwortet.
+     */
+    call<T = unknown>(operationId: string, options?: CallOptions): Promise<T>;
+    /**
+     * Steht der Dienst, und wird unser Credential angenommen?
+     *
+     * ⭐ `available` und `authenticated` sind zwei Fragen, und der Bericht haelt sie
+     * auseinander. Ein Dienst, der laeuft, aber unser Credential ablehnt, ist nicht
+     * "verfuegbar" im Sinne dessen, der ihn benutzen will — und ein `authenticated:
+     * null` heisst "nicht gefragt", nie "in Ordnung".
+     */
+    checkHealth(options?: {
+        timeoutMs?: number;
+        signal?: AbortSignal;
+    }): Promise<OrvelloHealth>;
+    /** Was der Vertrag hergibt — ohne Netz, ohne Credential. */
+    capabilities(): OrvelloCapabilities;
+    /** Spricht die laufende Gegenstelle denselben Vertrag wie dieses SDK? */
+    diagnose(options?: {
+        timeoutMs?: number;
+        signal?: AbortSignal;
+    }): Promise<OrvelloDiagnosis>;
+    /**
+     * Wuerde dieser Aufruf heute klappen? Prueft den ganzen Weg — Erreichbarkeit,
+     * Vertrag, Credential — und schreibt dabei nichts.
+     *
+     * Gedacht fuer Verbindungs-Verwalter: eine Kante laesst sich damit turnusmaessig
+     * nachpruefen, ohne sie anzufassen, und vor einem freigegebenen Schreibschritt
+     * laesst sich zeigen, was er tun wuerde.
+     */
+    preflight(operationId: string, options?: PreflightOptions): Promise<PreflightReport>;
+    /**
+     * Ein ausschliesslich lesender Aufruf auf einer Credential-Bahn.
+     *
+     * Je Bahn die guenstigste Frage, die ohne Nebenwirkung beantwortet, ob das
+     * Credential angenommen wird:
+     * - `api_key` → die Auflistung der Zugaenge mit `pageSize=1`
+     * - `bearer`  → das Holen des Tokens (der Dienst prueft dabei Kennung und Geheimnis)
+     */
+    private probeCredential;
     invoices: {
         search: (query?: InvoicesSearchExternalQuery, options?: RequestOptions) => Promise<InvoicesSearchExternalResponseData>;
         getById: (id: number, options?: RequestOptions) => Promise<Invoice>;
@@ -219,4 +636,4 @@ declare function createOrvelloClient(config?: OrvelloClientConfig): OrvelloClien
 
 declare const CONTRACT_SHA256 = "4efd4e4b669168c9cab5419fa04dd4e26a2029de2d4b10a59918e366189e1072";
 
-export { type AuthProvider, type BankAccountDetails, type BaseUrlProvider, BookkeepingExpensesCreateExternalBody, BookkeepingExpensesCreateExternalResponseData, BookkeepingPaymentsCreateManualExternalBody, BookkeepingPaymentsListAccountsExternalQuery, BookkeepingPaymentsListAccountsExternalResponseData, BookkeepingPaymentsSettleInvoiceExternalBody, BookkeepingPaymentsSettleInvoiceExternalResponseData, BookkeepingRevenue, BookkeepingRevenuesCreateExternalBody, BookkeepingRevenuesInvoiceAdjustmentExternalBody, BookkeepingRevenuesInvoiceAdjustmentExternalResponseData, CONTRACT_SHA256, CustomerCompaniesCreateExternalBody, CustomerCompaniesSearchExternalQuery, CustomerCompaniesSearchExternalResponseData, CustomerCompaniesUpdateExternalBody, CustomerCompany, DunningGetSettingsExternalResponseData, DunningIssueExternalBody, DunningIssueExternalResponseData, DunningPreviewExternalBody, DunningPreviewExternalResponseData, DunningSuggestionsExternalQuery, DunningSuggestionsExternalResponseData, DunningUpdateSettingsExternalBody, DunningUpdateSettingsExternalResponseData, type ExpenseReceiptUpload, Invoice, InvoicesCreateExternalBody, InvoicesCreateExternalResponseData, InvoicesCreditNoteIssueExternalBody, InvoicesCreditNoteIssueExternalResponseData, InvoicesCreditNotePreviewExternalBody, InvoicesCreditNotePreviewExternalResponseData, InvoicesOverdueExternalResponseData, InvoicesPendingExternalResponseData, InvoicesSearchExternalQuery, InvoicesSearchExternalResponseData, InvoicesSendEmailExternalBody, InvoicesSendEmailExternalResponseData, InvoicesStatusPolicyExternalResponseData, InvoicesUpdateStatusExternalBody, ManagingCompaniesCurrentExternalResponseData, NodeBillUser, Oauth2ExternalClientsCreateBody, Oauth2ExternalClientsCreateResponseData, Oauth2ExternalClientsGetResponseData, Oauth2ExternalClientsListQuery, Oauth2ExternalClientsListResponseData, Oauth2ExternalClientsRetireResponseData, Oauth2ExternalClientsRollbackResponseData, Oauth2ExternalClientsRotateBody, Oauth2ExternalClientsRotateResponseData, Oauth2ExternalClientsUpdateBody, Oauth2ExternalClientsUpdateResponseData, OrvelloApiError, OrvelloClient, type OrvelloClientConfig, type OrvelloContractStatus, type OrvelloDiagnoseOptions, type OrvelloDiagnosis, Payment, PaymentAccount, type RequestOptions, UsersUpdateExternalBody, buildBase64Receipt, calculateVat, createOrvelloClient, diagnoseOrvello, formatAmount, isKleinunternehmer, mapPaymentAccountToBankDetails };
+export { type AuthProvider, type BankAccountDetails, type BaseUrlProvider, BookkeepingExpensesCreateExternalBody, BookkeepingExpensesCreateExternalResponseData, BookkeepingPaymentsCreateManualExternalBody, BookkeepingPaymentsListAccountsExternalQuery, BookkeepingPaymentsListAccountsExternalResponseData, BookkeepingPaymentsSettleInvoiceExternalBody, BookkeepingPaymentsSettleInvoiceExternalResponseData, BookkeepingRevenue, BookkeepingRevenuesCreateExternalBody, BookkeepingRevenuesInvoiceAdjustmentExternalBody, BookkeepingRevenuesInvoiceAdjustmentExternalResponseData, CONTRACT_SHA256, type CallOptions, type CircuitBreakerConfig, type CircuitBreakerState, CustomerCompaniesCreateExternalBody, CustomerCompaniesSearchExternalQuery, CustomerCompaniesSearchExternalResponseData, CustomerCompaniesUpdateExternalBody, CustomerCompany, DunningGetSettingsExternalResponseData, DunningIssueExternalBody, DunningIssueExternalResponseData, DunningPreviewExternalBody, DunningPreviewExternalResponseData, DunningSuggestionsExternalQuery, DunningSuggestionsExternalResponseData, DunningUpdateSettingsExternalBody, DunningUpdateSettingsExternalResponseData, type ExpenseReceiptUpload, HEALTH_PATH, type HeadersProvider, Invoice, InvoicesCreateExternalBody, InvoicesCreateExternalResponseData, InvoicesCreditNoteIssueExternalBody, InvoicesCreditNoteIssueExternalResponseData, InvoicesCreditNotePreviewExternalBody, InvoicesCreditNotePreviewExternalResponseData, InvoicesOverdueExternalResponseData, InvoicesPendingExternalResponseData, InvoicesSearchExternalQuery, InvoicesSearchExternalResponseData, InvoicesSendEmailExternalBody, InvoicesSendEmailExternalResponseData, InvoicesStatusPolicyExternalResponseData, InvoicesUpdateStatusExternalBody, ManagingCompaniesCurrentExternalResponseData, NodeBillUser, Oauth2ExternalClientsCreateBody, Oauth2ExternalClientsCreateResponseData, Oauth2ExternalClientsGetResponseData, Oauth2ExternalClientsListQuery, Oauth2ExternalClientsListResponseData, Oauth2ExternalClientsRetireResponseData, Oauth2ExternalClientsRollbackResponseData, Oauth2ExternalClientsRotateBody, Oauth2ExternalClientsRotateResponseData, Oauth2ExternalClientsUpdateBody, Oauth2ExternalClientsUpdateResponseData, OrvelloApiError, type OrvelloAuthChannel, type OrvelloCapabilities, type OrvelloCapability, OrvelloClient, type OrvelloClientConfig, type OrvelloContractStatus, type OrvelloDiagnoseOptions, type OrvelloDiagnosis, type OrvelloHealth, type OrvelloOperation, OrvelloOperationError, type OrvelloOperationId, Payment, PaymentAccount, type PreflightHost, type PreflightOptions, type PreflightReport, type PreflightStep, type PreflightStepName, type RequestOptions, UsersUpdateExternalBody, type ValueProvider, authChannelForContractType, buildBase64Receipt, buildPath, calculateVat, createOrvelloClient, describeOperation, diagnoseOrvello, formatAmount, isKleinunternehmer, listOperations, mapPaymentAccountToBankDetails, orvelloCapabilities, preflightOrvello, resolveOperation };