@orvello/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,737 @@
+// src/contract-hash.ts
+var CONTRACT_SHA256 = "4efd4e4b669168c9cab5419fa04dd4e26a2029de2d4b10a59918e366189e1072";
+
+// src/diagnose.ts
+var SDK_VERSION = "0.1.0" ;
+function normalizeBaseUrl(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) throw new Error("Base URL cannot be empty");
+  return trimmed.replace(/\/+$/, "");
+}
+async function resolveBaseUrl(options) {
+  const provider = options.client?.baseUrl ?? options.baseUrl;
+  if (!provider) {
+    throw new Error(
+      "Diagnosing requires a target platform: pass { baseUrl } (the services checks its own baseUrl) \u2014 the SDK ships no baked-in default endpoint."
+    );
+  }
+  const value = typeof provider === "function" ? await provider() : provider;
+  return normalizeBaseUrl(value);
+}
+async function diagnoseOrvello(options = {}) {
+  const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
+  let baseUrl = null;
+  try {
+    baseUrl = await resolveBaseUrl(options);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return {
+      ok: false,
+      baseUrl: null,
+      sdkVersion: SDK_VERSION,
+      reachable: false,
+      contract: { status: "unknown", sdk: CONTRACT_SHA256, live: null, files: null },
+      problems: [`Invalid base URL: ${detail}`],
+      checkedAt
+    };
+  }
+  const doFetch = options.fetch ?? globalThis.fetch;
+  const timeoutMs = options.timeoutMs ?? 5e3;
+  const base = {
+    ok: false,
+    baseUrl,
+    sdkVersion: SDK_VERSION,
+    reachable: false,
+    contract: { status: "unknown", sdk: CONTRACT_SHA256, live: null, files: null },
+    problems: [],
+    checkedAt
+  };
+  if (typeof doFetch !== "function") {
+    return { ...base, problems: ["No fetch implementation available; pass `fetch` explicitly."] };
+  }
+  const controller = new AbortController();
+  const onAbort = () => controller.abort(options.signal?.reason);
+  options.signal?.addEventListener("abort", onAbort, { once: true });
+  if (options.signal?.aborted) controller.abort(options.signal.reason);
+  const timer = setTimeout(() => controller.abort(new Error(`Contract probe timed out after ${timeoutMs}ms`)), timeoutMs);
+  let response;
+  try {
+    response = await doFetch(`${baseUrl}/health/contract`, {
+      method: "GET",
+      headers: { accept: "application/json" },
+      signal: controller.signal
+    });
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return { ...base, problems: [`the orvello service at ${baseUrl} could not be reached: ${detail}`] };
+  } finally {
+    clearTimeout(timer);
+    options.signal?.removeEventListener("abort", onAbort);
+  }
+  if (response.status === 404) {
+    return {
+      ...base,
+      reachable: true,
+      problems: [
+        `the orvello service at ${baseUrl} does not serve GET /health/contract, so the contract cannot be verified.`
+      ]
+    };
+  }
+  if (!response.ok) {
+    return {
+      ...base,
+      reachable: true,
+      problems: [`the orvello service at ${baseUrl} answered ${response.status} for GET /health/contract; contract not verified.`]
+    };
+  }
+  let body;
+  try {
+    body = await response.json();
+  } catch {
+    return { ...base, reachable: true, problems: [`the orvello service at ${baseUrl} returned a non-JSON contract fingerprint.`] };
+  }
+  const live = typeof body.contractSha256 === "string" && body.contractSha256 ? body.contractSha256 : null;
+  const files = typeof body.files === "number" ? body.files : null;
+  if (!live) {
+    return {
+      ...base,
+      reachable: true,
+      contract: { ...base.contract, files },
+      problems: [`the orvello service at ${baseUrl} could not compute its own contract fingerprint; contract not verified.`]
+    };
+  }
+  if (live !== CONTRACT_SHA256) {
+    return {
+      ...base,
+      reachable: true,
+      contract: { status: "drift", sdk: CONTRACT_SHA256, live, files },
+      problems: [
+        `Contract drift: the orvello service at ${baseUrl} speaks ${live.slice(0, 12)}, @orvello/sdk ${SDK_VERSION} was built against ${CONTRACT_SHA256.slice(0, 12)}. Pin a newer SDK version, or deploy the orvello service the SDK was built from.`
+      ]
+    };
+  }
+  return {
+    ...base,
+    ok: true,
+    reachable: true,
+    contract: { status: "match", sdk: CONTRACT_SHA256, live, files }
+  };
+}
+
+// src/helpers.ts
+function buildBase64Receipt(data, fileName, mimeType) {
+  let base64String;
+  let size;
+  if (typeof data === "string") {
+    base64String = data.startsWith("data:") ? data.split(",")[1] || data : data;
+    size = Math.round(base64String.length * 3 / 4);
+  } else {
+    const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
+    size = bytes.byteLength;
+    if (typeof Buffer !== "undefined") {
+      base64String = Buffer.from(bytes).toString("base64");
+    } else {
+      let binary = "";
+      for (let i = 0; i < bytes.length; i++) {
+        binary += String.fromCharCode(bytes[i] ?? 0);
+      }
+      base64String = globalThis.btoa(binary);
+    }
+  }
+  return {
+    base64String,
+    fileName,
+    mimeType,
+    size
+  };
+}
+function isKleinunternehmer(context) {
+  return context.taxation?.defaultVatTreatmentHint === "KLEINUNTERNEHMER_0" || context.taxation?.regime?.toLowerCase() === "kleinunternehmer" || context.taxation?.shouldShowVatOnInvoices === false;
+}
+function calculateVat(netAmount, vatRatePercent) {
+  const netNum = typeof netAmount === "string" ? parseFloat(netAmount) : netAmount;
+  if (isNaN(netNum)) {
+    throw new Error(`Invalid net amount: "${netAmount}"`);
+  }
+  const vatNum = Math.round(netNum * vatRatePercent) / 100;
+  const grossNum = Math.round((netNum + vatNum) * 100) / 100;
+  return {
+    net: netNum.toFixed(2),
+    vat: vatNum.toFixed(2),
+    gross: grossNum.toFixed(2)
+  };
+}
+function formatAmount(amount, currency = "EUR", locale = "de-DE") {
+  const num = typeof amount === "string" ? parseFloat(amount) : amount;
+  if (isNaN(num)) return String(amount);
+  return new Intl.NumberFormat(locale, {
+    style: "currency",
+    currency
+  }).format(num);
+}
+function mapPaymentAccountToBankDetails(account) {
+  return {
+    id: account.id,
+    iban: account.iban || "",
+    bic: account.bic || "",
+    bank: account.bankName || "",
+    accountHolder: account.accountOwner || "",
+    currency: account.currency,
+    isDefault: account.isDefault
+  };
+}
+
+// src/client.ts
+var OrvelloApiError = class extends Error {
+  constructor(status, statusText, endpoint, body, message) {
+    super(message || `orvello request to ${endpoint} failed with status ${status}: ${statusText}`);
+    this.status = status;
+    this.statusText = statusText;
+    this.endpoint = endpoint;
+    this.body = body;
+    this.name = "OrvelloApiError";
+  }
+  status;
+  statusText;
+  endpoint;
+  body;
+  /** Readable alias for the primary `status` field. */
+  get statusCode() {
+    return this.status;
+  }
+  /** Readable alias for the raw `body` payload. */
+  get responseBody() {
+    return this.body;
+  }
+};
+var OrvelloClient = class {
+  baseUrl;
+  auth;
+  doFetch;
+  timeoutMs;
+  maxRetries;
+  retryBaseDelayMs;
+  cachedOAuthToken = null;
+  // Cached default bank account (5 minutes TTL)
+  _bankAccountCache = null;
+  _bankAccountCacheTime = 0;
+  constructor(config = {}) {
+    const baseUrl = config.baseUrl ?? this.envBaseUrl();
+    if (!baseUrl) {
+      throw new Error(
+        "OrvelloClient requires a target platform: pass { baseUrl } or set the ORVELLO_URL environment variable. The SDK deliberately ships no baked-in default endpoint."
+      );
+    }
+    this.baseUrl = baseUrl;
+    if (config.auth) {
+      this.auth = config.auth;
+    } else {
+      this.auth = this.envAuth();
+    }
+    this.doFetch = config.fetch || globalThis.fetch;
+    this.timeoutMs = config.timeoutMs ?? 15e3;
+    this.maxRetries = config.maxRetries ?? 3;
+    this.retryBaseDelayMs = config.retryBaseDelayMs ?? 500;
+  }
+  envBaseUrl() {
+    if (typeof process === "undefined" || !process?.env) return void 0;
+    const url = process.env.ORVELLO_URL;
+    return url ? url : void 0;
+  }
+  envAuth() {
+    if (typeof process === "undefined" || !process?.env) return void 0;
+    const clientId = process.env.ORVELLO_OAUTH_CLIENT_ID;
+    const clientSecret = process.env.ORVELLO_OAUTH_CLIENT_SECRET;
+    const apiKey = process.env.ORVELLO_API_KEY;
+    const scope = process.env.ORVELLO_OAUTH_SCOPE;
+    if (clientId && clientSecret && clientId !== "todo" && clientSecret !== "todo") {
+      return { clientId, clientSecret, ...scope ? { scope } : {} };
+    }
+    if (apiKey) return { apiKey };
+    return void 0;
+  }
+  async resolveBaseUrl() {
+    const val = typeof this.baseUrl === "function" ? await this.baseUrl() : this.baseUrl;
+    return val.replace(/\/+$/, "");
+  }
+  async getAuthHeader() {
+    if (!this.auth) return null;
+    if (typeof this.auth === "string") {
+      return this.auth.startsWith("Bearer ") ? this.auth : `Bearer ${this.auth}`;
+    }
+    if (typeof this.auth === "function") {
+      const token = await this.auth();
+      return token.startsWith("Bearer ") ? token : `Bearer ${token}`;
+    }
+    if (typeof this.auth === "object" && "apiKey" in this.auth && typeof this.auth.apiKey === "string") {
+      const key = this.auth.apiKey;
+      return key.startsWith("Bearer ") ? key : `Bearer ${key}`;
+    }
+    if (typeof this.auth === "object" && "clientId" in this.auth && "clientSecret" in this.auth) {
+      const now = Date.now();
+      if (this.cachedOAuthToken && this.cachedOAuthToken.expiresAt > now + 3e4) {
+        return `Bearer ${this.cachedOAuthToken.token}`;
+      }
+      const baseUrl = await this.resolveBaseUrl();
+      const tokenEndpoint = this.auth.tokenUrl || `${baseUrl}/oauth/token`;
+      const credentials = typeof Buffer !== "undefined" ? Buffer.from(`${this.auth.clientId}:${this.auth.clientSecret}`).toString("base64") : globalThis.btoa(`${this.auth.clientId}:${this.auth.clientSecret}`);
+      const bodyParams = new URLSearchParams({
+        grant_type: "client_credentials",
+        client_id: this.auth.clientId,
+        client_secret: this.auth.clientSecret
+      });
+      if (this.auth.scope) {
+        bodyParams.set("scope", this.auth.scope);
+      }
+      const resp = await this.doFetch(tokenEndpoint, {
+        method: "POST",
+        headers: {
+          "Authorization": `Basic ${credentials}`,
+          "Content-Type": "application/x-www-form-urlencoded"
+        },
+        body: bodyParams.toString()
+      });
+      if (!resp.ok) {
+        let errBody;
+        try {
+          errBody = await resp.json();
+        } catch {
+          errBody = await resp.text().catch(() => "");
+        }
+        throw new OrvelloApiError(
+          resp.status,
+          resp.statusText,
+          tokenEndpoint,
+          errBody,
+          "Failed to obtain OAuth2 token from the orvello service"
+        );
+      }
+      const data = await resp.json();
+      const expiresIn = data.expires_in || 3600;
+      this.cachedOAuthToken = {
+        token: data.access_token,
+        expiresAt: now + expiresIn * 1e3
+      };
+      return `Bearer ${data.access_token}`;
+    }
+    return null;
+  }
+  isRetriable(status, error) {
+    if (status !== null) {
+      return status >= 500 || status === 429;
+    }
+    if (error instanceof Error) {
+      const msg = error.message.toLowerCase();
+      return error.name === "AbortError" || error.name === "TimeoutError" || msg.includes("fetch failed") || msg.includes("network") || msg.includes("econnrefused") || msg.includes("etimedout") || msg.includes("enotfound") || msg.includes("socket");
+    }
+    return false;
+  }
+  async request(path, options = {}) {
+    const maxRetries = options.maxRetries ?? this.maxRetries;
+    const timeoutMs = options.timeoutMs ?? this.timeoutMs;
+    const baseUrl = await this.resolveBaseUrl();
+    const cleanPath = path.startsWith("/") ? path : `/${path}`;
+    const url = new URL(`${baseUrl}${cleanPath}`);
+    if (options.query) {
+      for (const [k, v] of Object.entries(options.query)) {
+        if (v !== void 0 && v !== null) {
+          url.searchParams.set(k, String(v));
+        }
+      }
+    }
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      const controller = new AbortController();
+      const onAbort = () => controller.abort(options.signal?.reason);
+      options.signal?.addEventListener("abort", onAbort, { once: true });
+      if (options.signal?.aborted) controller.abort(options.signal.reason);
+      const timer = setTimeout(
+        () => controller.abort(new Error(`Request timed out after ${timeoutMs}ms`)),
+        timeoutMs
+      );
+      try {
+        const authHeader = await this.getAuthHeader();
+        const headers = new Headers(options.headers);
+        if (!headers.has("Accept")) {
+          headers.set("Accept", options.rawResponse ? "*/*" : "application/json");
+        }
+        if (authHeader && !headers.has("Authorization")) {
+          headers.set("Authorization", authHeader);
+        }
+        if (options.idempotencyKey && !headers.has("Idempotency-Key")) {
+          headers.set("Idempotency-Key", options.idempotencyKey);
+        }
+        if (options.body && typeof options.body === "string" && !headers.has("Content-Type")) {
+          headers.set("Content-Type", "application/json");
+        }
+        const resp = await this.doFetch(url.toString(), {
+          ...options,
+          headers,
+          signal: controller.signal
+        });
+        if (!resp.ok) {
+          if (resp.status === 401) {
+            const hadCachedToken = Boolean(this.cachedOAuthToken);
+            this.cachedOAuthToken = null;
+            if (hadCachedToken && attempt === 0 && attempt < maxRetries) {
+              continue;
+            }
+          }
+          let errBody;
+          try {
+            errBody = await resp.json();
+          } catch {
+            errBody = await resp.text().catch(() => null);
+          }
+          const apiMessage = errBody && typeof errBody === "object" && "message" in errBody && typeof errBody.message === "string" ? errBody.message : void 0;
+          const error = new OrvelloApiError(resp.status, resp.statusText, cleanPath, errBody, apiMessage);
+          if (!this.isRetriable(resp.status, error) || attempt >= maxRetries) {
+            throw error;
+          }
+          lastError = error;
+        } else {
+          const contentType = resp.headers.get("content-type") || "";
+          if (options.rawResponse || contentType.includes("application/pdf")) {
+            return await resp.blob();
+          }
+          if (contentType.includes("application/json")) {
+            const json = await resp.json();
+            if (json && typeof json === "object" && "success" in json) {
+              const env = json;
+              if (env.success === false) {
+                throw new OrvelloApiError(resp.status, resp.statusText, cleanPath, json, env.message || "API returned success=false");
+              }
+              return env.data;
+            }
+            return json;
+          }
+          return await resp.text();
+        }
+      } catch (err) {
+        lastError = err;
+        if (err instanceof OrvelloApiError && !this.isRetriable(err.status, err)) {
+          throw err;
+        }
+        if (!this.isRetriable(null, err) || attempt >= maxRetries) {
+          throw err;
+        }
+      } finally {
+        clearTimeout(timer);
+        options.signal?.removeEventListener("abort", onAbort);
+      }
+      const jitter = Math.random() * 100;
+      const delay = this.retryBaseDelayMs * Math.pow(2, attempt) + jitter;
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+    throw lastError;
+  }
+  // ── Invoices ─────────────────────────────────────────────────────────────
+  invoices = {
+    search: (query, options) => this.request("/invoices/external", {
+      method: "GET",
+      query,
+      ...options
+    }),
+    getById: (id, options) => this.request(`/invoices/external/${id}`, {
+      method: "GET",
+      ...options
+    }),
+    getPending: (options) => this.request("/invoices/external/pending", {
+      method: "GET",
+      ...options
+    }),
+    getOverdue: (options) => this.request("/invoices/external/overdue", {
+      method: "GET",
+      ...options
+    }),
+    getStatusPolicy: (id, options) => this.request(`/invoices/external/${id}/status-policy`, {
+      method: "GET",
+      ...options
+    }),
+    create: (body, options) => this.request("/invoices/external", {
+      method: "POST",
+      body: JSON.stringify(body),
+      ...options
+    }),
+    updateStatus: (id, body, options) => this.request(`/invoices/external/${id}/status`, {
+      method: "PUT",
+      body: JSON.stringify(body),
+      ...options
+    }),
+    previewCreditNote: (id, body, options) => this.request(`/invoices/external/${id}/credit-note/preview`, {
+      method: "POST",
+      body: JSON.stringify(body),
+      ...options
+    }),
+    issueCreditNote: (id, body, options) => this.request(`/invoices/external/${id}/credit-note/issue`, {
+      method: "POST",
+      body: JSON.stringify(body),
+      ...options
+    }),
+    delete: (id, options) => this.request(`/invoices/external/${id}`, {
+      method: "DELETE",
+      ...options
+    }),
+    viewPdf: (id, options) => this.request(`/invoices/external/${id}/pdf`, {
+      method: "GET",
+      rawResponse: true,
+      ...options
+    }),
+    downloadPdf: (id, options) => this.request(`/invoices/external/${id}/download`, {
+      method: "GET",
+      rawResponse: true,
+      ...options
+    }),
+    sendEmail: (id, body, options) => this.request(`/invoices/external/${id}/send-email`, {
+      method: "POST",
+      body: JSON.stringify(body),
+      ...options
+    }),
+    downloadPdfFromUrl: async (pdfUrl, options) => {
+      const baseUrl = await this.resolveBaseUrl();
+      const targetUrl = pdfUrl.startsWith("http://") || pdfUrl.startsWith("https://") ? pdfUrl : `${baseUrl}${pdfUrl.startsWith("/") ? "" : "/"}${pdfUrl}`;
+      const doFetch = this.doFetch;
+      const authHeader = await this.getAuthHeader();
+      const headers = new Headers(options?.headers);
+      if (authHeader && !headers.has("Authorization")) {
+        headers.set("Authorization", authHeader);
+      }
+      const resp = await doFetch(targetUrl, {
+        method: "GET",
+        headers,
+        signal: options?.signal
+      });
+      if (!resp.ok) {
+        throw new OrvelloApiError(resp.status, resp.statusText, targetUrl, null, `Failed to download PDF from ${targetUrl}`);
+      }
+      return await resp.blob();
+    }
+  };
+  // ── Customer Companies ───────────────────────────────────────────────────
+  customerCompanies = {
+    search: (query, options) => this.request("/customer-companies/external", {
+      method: "GET",
+      query,
+      ...options
+    }),
+    getById: (id, options) => this.request(`/customer-companies/external/${id}`, {
+      method: "GET",
+      ...options
+    }),
+    create: (body, options) => this.request("/customer-companies/external", {
+      method: "POST",
+      body: JSON.stringify(body),
+      ...options
+    }),
+    update: (id, body, options) => this.request(`/customer-companies/external/${id}`, {
+      method: "PUT",
+      body: JSON.stringify(body),
+      ...options
+    }),
+    delete: (id, options) => this.request(`/customer-companies/external/${id}`, {
+      method: "DELETE",
+      ...options
+    })
+  };
+  // ── Managing Companies ───────────────────────────────────────────────────
+  managingCompanies = {
+    getCurrent: (options) => this.request("/managing-companies/external/current", {
+      method: "GET",
+      ...options
+    })
+  };
+  // ── Dunning ──────────────────────────────────────────────────────────────
+  dunning = {
+    suggestions: (query, options) => this.request("/invoices/external/dunning/suggestions", {
+      method: "GET",
+      query,
+      ...options
+    }),
+    preview: (invoiceId, body, options) => this.request(`/invoices/external/dunning/${invoiceId}/preview`, {
+      method: "POST",
+      body: body ? JSON.stringify(body) : void 0,
+      ...options
+    }),
+    issue: (invoiceId, body, options) => this.request(`/invoices/external/dunning/${invoiceId}/issue`, {
+      method: "POST",
+      body: JSON.stringify(body),
+      ...options
+    }),
+    getNoticePdf: (noticeId, options) => this.request(`/invoices/external/dunning/notices/${noticeId}/pdf`, {
+      method: "GET",
+      rawResponse: true,
+      ...options
+    }),
+    downloadNoticePdf: (noticeId, options) => this.request(`/invoices/external/dunning/notices/${noticeId}/download`, {
+      method: "GET",
+      rawResponse: true,
+      ...options
+    }),
+    getSettings: (options) => this.request("/invoices/external/dunning/settings", {
+      method: "GET",
+      ...options
+    }),
+    updateSettings: (body, options) => this.request("/invoices/external/dunning/settings", {
+      method: "PUT",
+      body: JSON.stringify(body),
+      ...options
+    })
+  };
+  // ── Bookkeeping ──────────────────────────────────────────────────────────
+  bookkeeping = {
+    revenues: {
+      create: (body, options) => {
+        const idempotencyKey = options?.idempotencyKey || body.externalRef;
+        return this.request("/bookkeeping/revenues/external", {
+          method: "POST",
+          body: JSON.stringify(body),
+          idempotencyKey,
+          ...options
+        });
+      },
+      createInvoiceAdjustment: (body, options) => {
+        const idempotencyKey = options?.idempotencyKey || body.externalRef;
+        return this.request(
+          "/bookkeeping/revenues/external/invoice-adjustment",
+          {
+            method: "POST",
+            body: JSON.stringify(body),
+            idempotencyKey,
+            ...options
+          }
+        );
+      }
+    },
+    expenses: {
+      create: (body, options) => {
+        const { receipt, ...reqOpts } = options || {};
+        const payload = receipt ? { ...body, ...receipt } : body;
+        const idempotencyKey = reqOpts.idempotencyKey || body.externalRef;
+        return this.request("/bookkeeping/expenses/external", {
+          method: "POST",
+          body: JSON.stringify(payload),
+          idempotencyKey,
+          ...reqOpts
+        });
+      }
+    },
+    payments: {
+      listAccounts: (options, reqOptions) => this.request("/bookkeeping/payments/external/accounts", {
+        method: "GET",
+        query: options,
+        ...reqOptions
+      }),
+      createManual: (body, options) => {
+        const idempotencyKey = options?.idempotencyKey || body.externalRef;
+        return this.request(
+          "/bookkeeping/payments/external/manual",
+          {
+            method: "POST",
+            body: JSON.stringify(body),
+            idempotencyKey,
+            ...options
+          }
+        );
+      },
+      settleInvoice: (body, options) => {
+        const idempotencyKey = options?.idempotencyKey || body.externalRef || `settle-${body.invoiceId}-${Date.now()}`;
+        return this.request(
+          "/bookkeeping/payments/external/settle-invoice",
+          {
+            method: "POST",
+            body: JSON.stringify(body),
+            idempotencyKey,
+            ...options
+          }
+        );
+      }
+    },
+    getDefaultBankAccount: async (options) => {
+      const now = Date.now();
+      if (!options?.forceRefresh && this._bankAccountCache && now - this._bankAccountCacheTime < 5 * 60 * 1e3) {
+        return this._bankAccountCache;
+      }
+      const accounts = await this.bookkeeping.payments.listAccounts({ includeArchived: false });
+      const bankAccounts = (accounts || []).filter((a) => a.type === "bank" && !a.isArchived);
+      let target = bankAccounts.find((a) => a.isDefault);
+      if (!target && bankAccounts.length === 1) {
+        target = bankAccounts[0];
+      }
+      if (!target) {
+        throw new Error(
+          "Kein Default-Bankkonto im orvello-Dienst gefunden. Bitte dort ein Bankkonto als Standard markieren."
+        );
+      }
+      const result = mapPaymentAccountToBankDetails(target);
+      this._bankAccountCache = result;
+      this._bankAccountCacheTime = now;
+      return result;
+    }
+  };
+  // ── Users ────────────────────────────────────────────────────────────────
+  users = {
+    getByExternalUserId: (externalUserId, options) => this.request(`/users/getByExternalUserId/${encodeURIComponent(externalUserId)}`, {
+      method: "GET",
+      ...options
+    }),
+    update: (frontendUserId, body, options) => this.request(`/users/update/external/${frontendUserId}`, {
+      method: "PUT",
+      body: JSON.stringify(body),
+      ...options
+    }),
+    delete: (frontendUserId, options) => this.request(`/users/delete/external/${frontendUserId}`, {
+      method: "DELETE",
+      ...options
+    })
+  };
+  // ── OAuth2 External Clients (Connection Manager) ─────────────────────────
+  oauthClients = {
+    list: (query, options) => this.request("/oauth/clients/external/list", {
+      method: "GET",
+      query,
+      ...options
+    }),
+    get: (idOrClientId, options) => this.request(`/oauth/clients/external/${encodeURIComponent(idOrClientId)}`, {
+      method: "GET",
+      ...options
+    }),
+    create: (body, options) => this.request("/oauth/clients/external", {
+      method: "POST",
+      body: JSON.stringify(body),
+      ...options
+    }),
+    update: (idOrClientId, body, options) => this.request(`/oauth/clients/external/${encodeURIComponent(idOrClientId)}`, {
+      method: "PUT",
+      body: JSON.stringify(body),
+      ...options
+    }),
+    delete: (idOrClientId, options) => this.request(`/oauth/clients/external/${encodeURIComponent(idOrClientId)}`, {
+      method: "DELETE",
+      ...options
+    }),
+    rotate: (idOrClientId, body, options) => this.request(`/oauth/clients/external/${encodeURIComponent(idOrClientId)}/rotate`, {
+      method: "POST",
+      body: body ? JSON.stringify(body) : void 0,
+      ...options
+    }),
+    retire: (idOrClientId, options) => this.request(`/oauth/clients/external/${encodeURIComponent(idOrClientId)}/retire`, {
+      method: "POST",
+      ...options
+    }),
+    rollback: (idOrClientId, options) => this.request(`/oauth/clients/external/${encodeURIComponent(idOrClientId)}/rollback`, {
+      method: "POST",
+      ...options
+    }),
+    revoke: (idOrClientId, options) => this.request(`/oauth/clients/external/${encodeURIComponent(idOrClientId)}/revoke`, {
+      method: "POST",
+      ...options
+    })
+  };
+};
+function createOrvelloClient(config) {
+  return new OrvelloClient(config);
+}
+
+export { CONTRACT_SHA256, OrvelloApiError, OrvelloClient, buildBase64Receipt, calculateVat, createOrvelloClient, diagnoseOrvello, formatAmount, isKleinunternehmer, mapPaymentAccountToBankDetails };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map