@delopay/sdk 0.274.0 → 0.279.0

package/dist/{chunk-R6E57AD4.js → chunk-5FGSME7D.js}

@@ -30,6 +30,100 @@ var DelopayAuthenticationError = class extends DelopayError {
   }
 };
 
+// src/eventStream.ts
+var LF = 10;
+var CR = 13;
+var EventStreamParser = class {
+  /**
+   * @param lastEventId - The id the stream resumes after, as `EventSource`
+   *   carries it into a reconnection: a dispatch before the server names an
+   *   id keeps this one.
+   */
+  constructor(lastEventId = "") {
+    this.line = "";
+    /** The previous chunk ended in CR: a LF opening the next one belongs to it. */
+    this.skipLf = false;
+    this.data = "";
+    this.hasData = false;
+    this.eventType = "";
+    this.retry = null;
+    this.idBuffer = lastEventId;
+  }
+  /** Feed the next piece of decoded text; returns the dispatches it completed. */
+  push(text) {
+    const out = [];
+    if (text.length === 0) return out;
+    let start = 0;
+    if (this.skipLf) {
+      this.skipLf = false;
+      if (text.charCodeAt(0) === LF) start = 1;
+    }
+    for (let i = start; i < text.length; i++) {
+      const c = text.charCodeAt(i);
+      if (c !== LF && c !== CR) continue;
+      const line = this.line + text.slice(start, i);
+      this.line = "";
+      this.processLine(line, out);
+      if (c === CR) {
+        if (i + 1 < text.length) {
+          if (text.charCodeAt(i + 1) === LF) i++;
+        } else {
+          this.skipLf = true;
+        }
+      }
+      start = i + 1;
+    }
+    this.line += text.slice(start);
+    return out;
+  }
+  processLine(line, out) {
+    if (line === "") {
+      this.dispatch(out);
+      return;
+    }
+    if (line.charCodeAt(0) === 58) return;
+    const colon = line.indexOf(":");
+    let field;
+    let value;
+    if (colon === -1) {
+      field = line;
+      value = "";
+    } else {
+      field = line.slice(0, colon);
+      value = line.slice(colon + 1);
+      if (value.charCodeAt(0) === 32) value = value.slice(1);
+    }
+    switch (field) {
+      case "event":
+        this.eventType = value;
+        break;
+      case "data":
+        this.data = this.hasData ? `${this.data}
+${value}` : value;
+        this.hasData = true;
+        break;
+      case "id":
+        if (!value.includes("\0")) this.idBuffer = value;
+        break;
+      case "retry":
+        if (/^[0-9]+$/.test(value)) {
+          const ms = Number(value);
+          if (Number.isSafeInteger(ms)) this.retry = ms;
+        }
+        break;
+      default:
+        break;
+    }
+  }
+  dispatch(out) {
+    const event = this.hasData ? { type: this.eventType || "message", data: this.data } : null;
+    out.push({ lastEventId: this.idBuffer, retry: this.retry, event });
+    this.data = "";
+    this.hasData = false;
+    this.eventType = "";
+  }
+};
+
 // src/resources/apiKeys.ts
 var ApiKeys = class {
   constructor(request) {
@@ -633,6 +727,23 @@ var Connectors = class {
       { body: params }
     );
   }
+  /**
+   * Fold copies of the same provider account into this connector (todos#395).
+   * `POST /account/{accountId}/connectors/{connectorId}/consolidate`
+   *
+   * The copies' shops move to the connector with their on/off state, routing,
+   * checkout layout, currencies, saved credentials, mandates and
+   * subscriptions. A copy keeps answering for the payments made on it and
+   * serves no shop. Send `dry_run: true` first, then confirm with the
+   * preview's `preview_token` and a choice for every conflict.
+   */
+  async consolidate(accountId, connectorId, params) {
+    return this.request(
+      "POST",
+      `/account/${encodeURIComponent(accountId)}/connectors/${encodeURIComponent(connectorId)}/consolidate`,
+      { body: params }
+    );
+  }
   /**
    * Switch a connector off, or back on, in one shop it serves.
    * `POST /account/{accountId}/connectors/{connectorId}/shops/{profileId}`
@@ -1258,8 +1369,8 @@ var Customers = class {
 };
 
 // src/recordCounter.ts
-var LF = 10;
-var CR = 13;
+var LF2 = 10;
+var CR2 = 13;
 var QUOTE = 34;
 var BACKSLASH = 92;
 var OPEN_BRACE = 123;
@@ -1283,10 +1394,10 @@ var CsvRecordCounter = class {
         lineHasContent = true;
       } else if (inQuotes) {
         lineHasContent = true;
-      } else if (byte === LF) {
+      } else if (byte === LF2) {
         newlines++;
         lineHasContent = false;
-      } else if (byte !== CR) {
+      } else if (byte !== CR2) {
         lineHasContent = true;
       }
     }
@@ -5776,6 +5887,55 @@ var BuyerConversations = class {
       body: params
     });
   }
+  /**
+   * A team member's internal note. Only the team reads it: the buyer never
+   * sees a note, and a note does not move the conversation or mark it unread.
+   * A closed conversation takes notes as well.
+   * `POST /buyer-conversations/{id}/notes`
+   */
+  async addNote(id, params) {
+    return this.request("POST", `/buyer-conversations/${encodeURIComponent(id)}/notes`, {
+      body: params
+    });
+  }
+  /**
+   * Upload a file for the caller's next answer, under the shop's attachment
+   * rules (`attachment_rules` on the conversation). It belongs to the caller
+   * until an answer names it in `attachments`; one no answer took within a
+   * day is cleared. Uploading again with the same `clientUploadId` returns
+   * the file the first upload stored.
+   * `POST /buyer-conversation-files/{conversation}`
+   */
+  async uploadFile(id, file, clientUploadId, fileName) {
+    const form = new FormData();
+    form.append("client_upload_id", clientUploadId);
+    if (fileName === void 0) form.append("file", file);
+    else form.append("file", file, fileName);
+    return this.request("POST", `/buyer-conversation-files/${encodeURIComponent(id)}`, {
+      body: form
+    });
+  }
+  /**
+   * Download a file a message of the conversation carries.
+   * `GET /buyer-conversation-files/{conversation}/{file}`
+   */
+  async downloadFile(id, fileId) {
+    return this.request(
+      "GET",
+      `/buyer-conversation-files/${encodeURIComponent(id)}/${encodeURIComponent(fileId)}`,
+      { responseType: "blob" }
+    );
+  }
+  /**
+   * Remove a file the caller uploaded that no answer took.
+   * `DELETE /buyer-conversation-files/{conversation}/{file}`
+   */
+  async removeFile(id, fileId) {
+    return this.request(
+      "DELETE",
+      `/buyer-conversation-files/${encodeURIComponent(id)}/${encodeURIComponent(fileId)}`
+    );
+  }
   /**
    * The team has read the conversation up to its last accepted message.
    * `POST /buyer-conversations/{id}/read`
@@ -7592,6 +7752,53 @@ var BuyerAccount = class {
       }
     );
   }
+  /**
+   * Upload a file for the buyer's next message to one shop of a confirmed
+   * record, under the shop's attachment rules (`attachment_rules` on the
+   * message page). It belongs to the buyer until a message names it in
+   * `attachments`; one no message took within a day is cleared. Uploading
+   * again with the same `clientUploadId` returns the file the first upload
+   * stored. `shop` is required here.
+   */
+  async uploadRecordMessageFile(record, file, clientUploadId, query, options) {
+    const { fileName, ...extras } = options ?? {};
+    const form = new FormData();
+    form.append("client_upload_id", clientUploadId);
+    if (fileName === void 0) form.append("file", file);
+    else form.append("file", file, fileName);
+    return this.request(
+      "POST",
+      `/buyer-account/records/${encodeURIComponent(record)}/messages/files`,
+      {
+        body: form,
+        query,
+        ...extras
+      }
+    );
+  }
+  /** Download a file a message of a record's conversation with one shop carries. */
+  async downloadRecordMessageFile(record, fileId, query, options) {
+    return this.request(
+      "GET",
+      `/buyer-account/records/${encodeURIComponent(record)}/messages/files/${encodeURIComponent(fileId)}`,
+      {
+        query,
+        responseType: "blob",
+        ...options
+      }
+    );
+  }
+  /** Remove a file the buyer uploaded for a record's conversation that no message took. */
+  async removeRecordMessageFile(record, fileId, query, options) {
+    return this.request(
+      "DELETE",
+      `/buyer-account/records/${encodeURIComponent(record)}/messages/files/${encodeURIComponent(fileId)}`,
+      {
+        query,
+        ...options
+      }
+    );
+  }
   /**
    * What the buyer spent in a period: paid purchases summed per currency,
    * never converted, for the whole period, per day, week or month, per shop
@@ -7814,6 +8021,40 @@ var BuyerPortal = class {
       ...options
     });
   }
+  /**
+   * Upload a file for the buyer's next message to one shop, under the shop's
+   * attachment rules (`attachment_rules` on the message page). It belongs to
+   * the buyer until a message names it in `attachments`; one no message took
+   * within a day is cleared. Uploading again with the same `clientUploadId`
+   * returns the file the first upload stored.
+   */
+  async uploadMessageFile(file, clientUploadId, query, options) {
+    const { fileName, ...extras } = options ?? {};
+    const form = new FormData();
+    form.append("client_upload_id", clientUploadId);
+    if (fileName === void 0) form.append("file", file);
+    else form.append("file", file, fileName);
+    return this.request("POST", "/buyer-portal/messages/files", {
+      body: form,
+      query,
+      ...extras
+    });
+  }
+  /** Download a file a message of the buyer's conversation with one shop carries. */
+  async downloadMessageFile(fileId, query, options) {
+    return this.request("GET", `/buyer-portal/messages/files/${encodeURIComponent(fileId)}`, {
+      query,
+      responseType: "blob",
+      ...options
+    });
+  }
+  /** Remove a file the buyer uploaded that no message took. */
+  async removeMessageFile(fileId, query, options) {
+    return this.request("DELETE", `/buyer-portal/messages/files/${encodeURIComponent(fileId)}`, {
+      query,
+      ...options
+    });
+  }
   /** The buyer's contact and billing details, and what they may change. */
   async getProfile(options) {
     return this.request("GET", "/buyer-portal/profile", { ...options });
@@ -8690,6 +8931,133 @@ var Risk = class {
   }
 };
 
+// src/resources/live.ts
+function readField(data, key) {
+  let value;
+  try {
+    value = JSON.parse(data);
+  } catch {
+    return void 0;
+  }
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return void 0;
+  return Object.getOwnPropertyDescriptor(value, key)?.value;
+}
+function toLiveStreamEvent(event, id, retry) {
+  switch (event.type) {
+    case "ready": {
+      const resumed = readField(event.data, "resumed");
+      return { type: "ready", id, retry, resumed: typeof resumed === "boolean" ? resumed : null };
+    }
+    case "change": {
+      const changes = readField(event.data, "changes");
+      if (!Array.isArray(changes)) return { type: "resync", id };
+      return { type: "change", id, changes };
+    }
+    case "resync":
+      return { type: "resync", id };
+    default:
+      return null;
+  }
+}
+var LiveEventStream = class {
+  constructor(connection, lastEventId = null) {
+    this.connection = connection;
+    this._retry = null;
+    this._lastEventId = lastEventId || null;
+  }
+  /**
+   * The position to resume after: the id of the last event read, advanced by
+   * keepalives too. `null` before the server named one. Send it as
+   * `lastEventId` when reconnecting.
+   */
+  get lastEventId() {
+    return this._lastEventId;
+  }
+  /** The wait before reconnecting the server asked for, in ms; `null` until it says. */
+  get retry() {
+    return this._retry;
+  }
+  /** Close the stream; the iteration ends without an error. */
+  close() {
+    this.connection.close();
+  }
+  [Symbol.asyncIterator]() {
+    this.iterator ?? (this.iterator = this.events());
+    return this.iterator;
+  }
+  async *events() {
+    for await (const dispatch of this.connection.dispatches) {
+      const event = this.read(dispatch);
+      if (event) yield event;
+    }
+  }
+  read(dispatch) {
+    this._lastEventId = dispatch.lastEventId || null;
+    if (dispatch.retry !== null) this._retry = dispatch.retry;
+    if (!dispatch.event) return null;
+    return toLiveStreamEvent(dispatch.event, this._lastEventId, this._retry);
+  }
+};
+async function openLiveStream(openStream, path, options = {}) {
+  const connection = await openStream(path, {
+    ...options.lastEventId ? { lastEventId: options.lastEventId } : {},
+    ...options.signal ? { signal: options.signal } : {},
+    ...options.idleTimeoutMs !== void 0 ? { idleTimeoutMs: options.idleTimeoutMs } : {},
+    ...options.headers ? { headers: options.headers } : {}
+  });
+  return new LiveEventStream(connection, options.lastEventId ?? null);
+}
+var Live = class {
+  constructor(request, openStream) {
+    this.request = request;
+    this.openStream = openStream;
+  }
+  /**
+   * Open the stream of what changed in the caller's merchant, as their role
+   * may read it. Resolves once the server answered; a `401` rejects with
+   * `DelopayAuthenticationError`.
+   *
+   * The first event is `ready`. `change` names the kinds of record and, when
+   * few, the ids that changed: read them again through the usual endpoints.
+   * `resync`, and `ready` with `resumed: false`, mean read everything again.
+   * The SDK does not reconnect — see {@link LiveEventStream}.
+   *
+   * `GET /live/stream`
+   *
+   * @example
+   * ```typescript
+   * const stream = await delopay.live.stream({ lastEventId, signal });
+   * for await (const event of stream) {
+   *   if (event.type === 'change') refresh(event.changes);
+   *   else if (event.type === 'resync' || event.resumed === false) refreshAll();
+   * }
+   * lastEventId = stream.lastEventId; // reconnect after stream.retry
+   * ```
+   */
+  async stream(options) {
+    return openLiveStream(this.openStream, "/live/stream", options);
+  }
+  /**
+   * The current version of each kind of record named, in the caller's
+   * merchant and shop. Read it before the record and send the entry's
+   * `if_match` in the `If-Match` header of the save: a save over a newer
+   * version is refused with `IR_16` (400), `error.data` a
+   * `LiveChangedElsewhere` naming who made the change.
+   *
+   * `GET /live/versions`
+   */
+  async versions(params, options) {
+    return this.request("GET", "/live/versions", {
+      query: {
+        entities: params.entities.join(","),
+        profile_id: params.profile_id,
+        record_id: params.record_id
+      },
+      ...options
+    });
+  }
+};
+
 // src/client.ts
 var PRODUCTION_URL = "https://api.delopay.net";
 var SANDBOX_URL = "https://sandbox.delopay.net";
@@ -8713,6 +9081,40 @@ function truncateRawBody(raw) {
   if (!raw) return void 0;
   return raw.length > MAX_RAW_BODY_BYTES ? raw.slice(0, MAX_RAW_BODY_BYTES) + "\u2026" : raw;
 }
+async function errorFromResponse(response, requestId) {
+  const rawBody = await response.text().catch(() => "");
+  let parsed = {};
+  if (rawBody) {
+    try {
+      parsed = JSON.parse(rawBody);
+    } catch {
+    }
+  }
+  const err = parsed.error ?? parsed;
+  const message = err.message ?? `Request failed with status ${response.status}`;
+  const code = err.code ?? "";
+  const type = err.error_type ?? err.type ?? "";
+  const data = err.data && typeof err.data === "object" && !Array.isArray(err.data) ? err.data : void 0;
+  const truncatedRaw = truncateRawBody(rawBody);
+  const isConnectorPassthrough = type === "connector" || code.startsWith("CE_");
+  if (response.status === 401 && !isConnectorPassthrough) {
+    return new DelopayAuthenticationError(message, {
+      code,
+      type,
+      requestId,
+      rawBody: truncatedRaw,
+      data
+    });
+  }
+  return new DelopayError(message, {
+    status: response.status,
+    code,
+    type,
+    requestId,
+    rawBody: truncatedRaw,
+    data
+  });
+}
 function findIdempotencyKey(headers) {
   for (const [k, v] of Object.entries(headers)) {
     if (k.toLowerCase() === "idempotency-key") return v;
@@ -8873,6 +9275,7 @@ function redactUrlForLogging(url) {
   });
   return `${base}?${parts.join("&")}`;
 }
+var DEFAULT_STREAM_IDLE_TIMEOUT_MS = 45e3;
 var Delopay = class {
   /**
    * Create a new Delopay client.
@@ -8895,6 +9298,7 @@ var Delopay = class {
       this.baseUrl = PRODUCTION_URL;
     }
     const request = this.request.bind(this);
+    const openStream = this.openEventStream.bind(this);
     this.payments = new Payments(request);
     this.refunds = new Refunds(request);
     this.customers = new Customers(request);
@@ -8931,6 +9335,7 @@ var Delopay = class {
     this.settings = new Settings(request);
     this.messageTemplates = new MessageTemplates(request);
     this.risk = new Risk(request);
+    this.live = new Live(request, openStream);
     this.subscriptions = new Subscriptions(request);
     this.buyerPortal = new BuyerPortal(request);
     this.buyerAccount = new BuyerAccount(request);
@@ -9007,24 +9412,12 @@ var Delopay = class {
     this.setJwtToken(response.token);
     return response;
   }
-  /**
-   * Make a raw HTTP request to the Delopay API.
-   *
-   * You rarely need to call this directly — prefer the typed resource methods.
-   * Use it only for endpoints not yet covered by a resource class.
-   *
-   * @param method - HTTP method (`GET`, `POST`, `PUT`, `PATCH`, `DELETE`).
-   * @param path - API path starting with `/` (e.g. `/payments`).
-   * @param options - Optional body, query parameters, and headers.
-   * @returns Parsed JSON response body typed as `T`.
-   * @throws {DelopayAuthenticationError} On 401 responses.
-   * @throws {DelopayError} On all other non-2xx responses, timeouts, and network errors.
-   */
-  async request(method, path, options) {
+  /** `path` on the base URL, with the query string `query` makes. */
+  buildUrl(path, query) {
     let url = `${this.baseUrl}${path}`;
-    if (options?.query) {
+    if (query) {
       const params = new URLSearchParams();
-      for (const [key, value] of Object.entries(options.query)) {
+      for (const [key, value] of Object.entries(query)) {
         if (value === void 0 || value === null) continue;
         if (Array.isArray(value)) {
           for (const v of value) {
@@ -9039,8 +9432,189 @@ var Delopay = class {
         url += `?${qs}`;
       }
     }
+    return url;
+  }
+  /** The credential header: the JWT when one is set, else the API key. */
+  authHeaders() {
+    if (this.jwtToken) return { Authorization: `Bearer ${this.jwtToken}` };
+    if (this.apiKey) return { "api-key": this.apiKey };
+    return {};
+  }
+  /** One debug event, when `debug` is on. */
+  log(event, data) {
+    if (!this.debug) return;
+    if (this.logger) {
+      this.logger(event, data);
+      return;
+    }
+    if (event === "request")
+      console.log(`[delopay] ${data.method} ${data.url}`);
+    else if (event === "response")
+      console.log(
+        `[delopay] ${data.status} ${data.method} ${data.path}`
+      );
+    else
+      console.log(
+        `[delopay] retry ${data.attempt}/${data.maxRetries} ${data.method} ${data.path}`
+      );
+  }
+  /**
+   * Open a `GET` `text/event-stream` and read it as it arrives.
+   *
+   * `request()` keeps every chunk of a body until the body ends, which a
+   * stream that stays open for half an hour must not do; this reads the body
+   * chunk by chunk through {@link EventStreamParser} and keeps nothing it has
+   * dispatched. Credentials, the base URL, debug logging and the mapping of a
+   * non-2xx answer to `DelopayError` / `DelopayAuthenticationError` are the
+   * ones `request()` uses.
+   *
+   * Never retried, and never reconnected: the caller owns reconnection.
+   * Resolves once the response headers arrive; rejects on a non-2xx answer,
+   * on a 2xx that is not `text/event-stream` (code `NOT_EVENT_STREAM`), and
+   * with `TIMEOUT`, `NETWORK` or `ABORTED` like `request()`.
+   */
+  async openEventStream(path, options = {}) {
+    const url = this.buildUrl(path, options.query);
+    const lastEventId = options.lastEventId ?? "";
+    const headers = {
+      ...this.authHeaders(),
+      Accept: "text/event-stream",
+      ...lastEventId ? { "Last-Event-ID": lastEventId } : {},
+      ...options.headers
+    };
+    const idleMs = options.idleTimeoutMs ?? DEFAULT_STREAM_IDLE_TIMEOUT_MS;
+    const callerSignal = options.signal;
+    const aborted = () => new DelopayError("Request aborted", { status: 0, code: "ABORTED", type: "abort_error" });
+    if (callerSignal?.aborted) throw aborted();
+    const idleCtrl = new AbortController();
+    const closeCtrl = new AbortController();
+    let timer;
+    const stopIdleTimer = () => {
+      if (timer !== void 0) clearTimeout(timer);
+      timer = void 0;
+    };
+    const startIdleTimer = () => {
+      stopIdleTimer();
+      if (!idleCtrl.signal.aborted) timer = setTimeout(() => idleCtrl.abort(), idleMs);
+    };
+    const combined = combineSignals(
+      callerSignal ? [idleCtrl.signal, closeCtrl.signal, callerSignal] : [idleCtrl.signal, closeCtrl.signal]
+    );
+    const release = () => {
+      stopIdleTimer();
+      combined.dispose();
+    };
+    const timedOut = () => new DelopayError(`Event stream silent for ${idleMs} ms`, {
+      status: 0,
+      code: "TIMEOUT",
+      type: "timeout_error"
+    });
+    const network = (cause) => new DelopayError(
+      `Network error: ${cause instanceof Error ? cause.message : String(cause ?? "stream failed")}`,
+      { status: 0, code: "NETWORK", type: "network_error" }
+    );
+    this.log("request", { method: "GET", url: redactUrlForLogging(url), path });
+    startIdleTimer();
+    let response;
+    try {
+      response = await fetch(url, { method: "GET", headers, signal: combined.signal });
+    } catch (err) {
+      release();
+      if (callerSignal?.aborted) throw aborted();
+      if (idleCtrl.signal.aborted) throw timedOut();
+      throw network(err);
+    }
+    const requestId = response.headers?.get("x-request-id") ?? response.headers?.get("x-trace-id") ?? void 0;
+    this.log("response", { status: response.status, method: "GET", path, requestId });
+    if (!response.ok) {
+      const error = await errorFromResponse(response, requestId);
+      release();
+      throw error;
+    }
+    const body = response.body;
+    const contentType = response.headers?.get("content-type") ?? "";
+    const mediaType = (contentType.split(";")[0] ?? "").trim().toLowerCase();
+    if (mediaType !== "text/event-stream" || !body || typeof body.getReader !== "function") {
+      release();
+      body?.cancel().catch(noop);
+      throw new DelopayError(
+        mediaType === "text/event-stream" ? "The event stream has no readable body" : `Expected a text/event-stream response, got ${contentType ? `"${contentType}"` : "no content type"}`,
+        {
+          status: response.status,
+          code: "NOT_EVENT_STREAM",
+          type: "invalid_response",
+          requestId
+        }
+      );
+    }
+    stopIdleTimer();
+    const reader = body.getReader();
+    const parser = new EventStreamParser(lastEventId);
+    const decoder = new TextDecoder();
+    const stopped = () => Boolean(callerSignal?.aborted) || closeCtrl.signal.aborted;
+    let finished = false;
+    const finish = () => {
+      if (finished) return;
+      finished = true;
+      release();
+      reader.cancel().catch(noop);
+    };
+    async function* dispatches() {
+      try {
+        for (; ; ) {
+          let result;
+          startIdleTimer();
+          try {
+            result = await readChunk(reader, combined.signal);
+          } catch (err) {
+            if (callerSignal?.aborted || closeCtrl.signal.aborted) return;
+            if (idleCtrl.signal.aborted) throw timedOut();
+            throw network(err instanceof BodyStreamFailure ? err.cause : err);
+          } finally {
+            stopIdleTimer();
+          }
+          if (result.done) {
+            for (const dispatch of parser.push(decoder.decode())) {
+              if (stopped()) return;
+              yield dispatch;
+            }
+            return;
+          }
+          if (!result.value || result.value.byteLength === 0) continue;
+          for (const dispatch of parser.push(decoder.decode(result.value, { stream: true }))) {
+            if (stopped()) return;
+            yield dispatch;
+          }
+        }
+      } finally {
+        finish();
+      }
+    }
+    return {
+      dispatches: dispatches(),
+      close: () => {
+        closeCtrl.abort();
+        finish();
+      }
+    };
+  }
+  /**
+   * Make a raw HTTP request to the Delopay API.
+   *
+   * You rarely need to call this directly — prefer the typed resource methods.
+   * Use it only for endpoints not yet covered by a resource class.
+   *
+   * @param method - HTTP method (`GET`, `POST`, `PUT`, `PATCH`, `DELETE`).
+   * @param path - API path starting with `/` (e.g. `/payments`).
+   * @param options - Optional body, query parameters, and headers.
+   * @returns Parsed JSON response body typed as `T`.
+   * @throws {DelopayAuthenticationError} On 401 responses.
+   * @throws {DelopayError} On all other non-2xx responses, timeouts, and network errors.
+   */
+  async request(method, path, options) {
+    const url = this.buildUrl(path, options?.query);
     let headers = {
-      ...this.jwtToken ? { Authorization: `Bearer ${this.jwtToken}` } : this.apiKey ? { "api-key": this.apiKey } : {},
+      ...this.authHeaders(),
       ...options?.headers
     };
     const isRawBody = options?.body !== void 0 && options?.body !== null && (options.body instanceof FormData || options.body instanceof Blob || options.body instanceof ArrayBuffer || options.body instanceof URLSearchParams);
@@ -9093,23 +9667,7 @@ var Delopay = class {
     let lastError;
     let retryAfterOverrideMs = null;
     const safeUrl = () => redactUrlForLogging(url);
-    const emit = (event, data) => {
-      if (!this.debug) return;
-      if (this.logger) {
-        this.logger(event, data);
-        return;
-      }
-      if (event === "request")
-        console.log(`[delopay] ${data.method} ${data.url}`);
-      else if (event === "response")
-        console.log(
-          `[delopay] ${data.status} ${data.method} ${data.path}`
-        );
-      else
-        console.log(
-          `[delopay] retry ${data.attempt}/${data.maxRetries} ${data.method} ${data.path}`
-        );
-    };
+    const emit = (event, data) => this.log(event, data);
     for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
       if (attempt > 0) {
         const base = Math.min(500 * 2 ** (attempt - 1), 5e3);
@@ -9141,38 +9699,7 @@ var Delopay = class {
         const requestId = response.headers?.get("x-request-id") ?? response.headers?.get("x-trace-id") ?? void 0;
         emit("response", { status: response.status, method, path, requestId });
         if (!response.ok) {
-          const rawBody = await response.text().catch(() => "");
-          let parsed = {};
-          if (rawBody) {
-            try {
-              parsed = JSON.parse(rawBody);
-            } catch {
-            }
-          }
-          const err = parsed.error ?? parsed;
-          const message = err.message ?? `Request failed with status ${response.status}`;
-          const code = err.code ?? "";
-          const type = err.error_type ?? err.type ?? "";
-          const data = err.data && typeof err.data === "object" && !Array.isArray(err.data) ? err.data : void 0;
-          const truncatedRaw = truncateRawBody(rawBody);
-          const isConnectorPassthrough = type === "connector" || code.startsWith("CE_");
-          if (response.status === 401 && !isConnectorPassthrough) {
-            throw new DelopayAuthenticationError(message, {
-              code,
-              type,
-              requestId,
-              rawBody: truncatedRaw,
-              data
-            });
-          }
-          const error = new DelopayError(message, {
-            status: response.status,
-            code,
-            type,
-            requestId,
-            rawBody: truncatedRaw,
-            data
-          });
+          const error = await errorFromResponse(response, requestId);
           const isTransientStatus = response.status >= 500 || response.status === 429;
           if (isTransientStatus && isRetryable && attempt < this.maxRetries) {
             if (response.status === 429) {
@@ -10640,6 +11167,13 @@ var DEFAULT_BRANDING_BASE = {
   paypalFocusRing: "strong",
   mollieFocusRing: "strong",
   paypalValidTint: false,
+  epayoutsCardLayout: "split",
+  epayoutsLabelStyle: "above",
+  epayoutsFieldChrome: "outlined",
+  epayoutsFieldFontSize: "md",
+  epayoutsFieldWeight: "regular",
+  epayoutsFocusRing: "strong",
+  epayoutsValidTint: false,
   nomupayFormStyle: "plain",
   nomupayShowLabels: true,
   nomupayShowPlaceholders: true,
@@ -11670,6 +12204,66 @@ function decodeBranding(source) {
       DEFAULT_BRANDING.whopSelection
     ),
     paypalValidTint: parseBool(extras["paypalValidTint"], DEFAULT_BRANDING.paypalValidTint),
+    // A look stored before todos#412 has no e-Payouts keys: the form keeps
+    // the PayPal values it was drawn with until then.
+    epayoutsCardLayout: pickEnum(
+      extras["epayoutsCardLayout"],
+      PAYPAL_CARD_LAYOUTS,
+      pickEnum(
+        extras["paypalCardLayout"],
+        PAYPAL_CARD_LAYOUTS,
+        DEFAULT_BRANDING.epayoutsCardLayout
+      )
+    ),
+    epayoutsLabelStyle: pickEnum(
+      extras["epayoutsLabelStyle"],
+      PAYPAL_LABEL_STYLES,
+      pickEnum(
+        extras["paypalLabelStyle"],
+        PAYPAL_LABEL_STYLES,
+        DEFAULT_BRANDING.epayoutsLabelStyle
+      )
+    ),
+    epayoutsFieldChrome: pickEnum(
+      extras["epayoutsFieldChrome"],
+      CARD_FIELD_CHROMES,
+      pickEnum(
+        extras["paypalFieldChrome"],
+        CARD_FIELD_CHROMES,
+        DEFAULT_BRANDING.epayoutsFieldChrome
+      )
+    ),
+    epayoutsFieldFontSize: pickEnum(
+      extras["epayoutsFieldFontSize"],
+      CARD_FIELD_FONT_SIZES,
+      pickEnum(
+        extras["paypalFieldFontSize"],
+        CARD_FIELD_FONT_SIZES,
+        DEFAULT_BRANDING.epayoutsFieldFontSize
+      )
+    ),
+    epayoutsFieldWeight: pickEnum(
+      extras["epayoutsFieldWeight"],
+      CARD_FIELD_WEIGHTS,
+      pickEnum(
+        extras["paypalFieldWeight"],
+        CARD_FIELD_WEIGHTS,
+        DEFAULT_BRANDING.epayoutsFieldWeight
+      )
+    ),
+    epayoutsFocusRing: pickEnum(
+      extras["epayoutsFocusRing"],
+      CARD_FOCUS_RINGS,
+      pickEnum(
+        extras["paypalFocusRing"],
+        CARD_FOCUS_RINGS,
+        DEFAULT_BRANDING.epayoutsFocusRing
+      )
+    ),
+    epayoutsValidTint: parseBool(
+      extras["epayoutsValidTint"],
+      parseBool(extras["paypalValidTint"], DEFAULT_BRANDING.epayoutsValidTint)
+    ),
     nomupayFormStyle: pickEnum(
       extras["nomupayFormStyle"],
       NOMUPAY_FORM_STYLES,
@@ -11831,6 +12425,13 @@ function encodeBranding(branding, base) {
     whopMethodIcons: String(branding.whopMethodIcons),
     whopSelection: branding.whopSelection,
     paypalValidTint: String(branding.paypalValidTint),
+    epayoutsCardLayout: branding.epayoutsCardLayout,
+    epayoutsLabelStyle: branding.epayoutsLabelStyle,
+    epayoutsFieldChrome: branding.epayoutsFieldChrome,
+    epayoutsFieldFontSize: branding.epayoutsFieldFontSize,
+    epayoutsFieldWeight: branding.epayoutsFieldWeight,
+    epayoutsFocusRing: branding.epayoutsFocusRing,
+    epayoutsValidTint: String(branding.epayoutsValidTint),
     nomupayFormStyle: branding.nomupayFormStyle,
     nomupayShowLabels: String(branding.nomupayShowLabels),
     nomupayShowPlaceholders: String(branding.nomupayShowPlaceholders),
@@ -12292,6 +12893,62 @@ function parseImportedBranding(raw) {
       dflt.whopSelection
     ),
     paypalValidTint: parseBool(root["paypalValidTint"], dflt.paypalValidTint),
+    // A look stored before todos#412 has no e-Payouts keys: the form keeps
+    // the PayPal values it was drawn with until then.
+    epayoutsCardLayout: pickEnum(
+      root["epayoutsCardLayout"],
+      PAYPAL_CARD_LAYOUTS,
+      pickEnum(
+        root["paypalCardLayout"],
+        PAYPAL_CARD_LAYOUTS,
+        dflt.epayoutsCardLayout
+      )
+    ),
+    epayoutsLabelStyle: pickEnum(
+      root["epayoutsLabelStyle"],
+      PAYPAL_LABEL_STYLES,
+      pickEnum(
+        root["paypalLabelStyle"],
+        PAYPAL_LABEL_STYLES,
+        dflt.epayoutsLabelStyle
+      )
+    ),
+    epayoutsFieldChrome: pickEnum(
+      root["epayoutsFieldChrome"],
+      CARD_FIELD_CHROMES,
+      pickEnum(
+        root["paypalFieldChrome"],
+        CARD_FIELD_CHROMES,
+        dflt.epayoutsFieldChrome
+      )
+    ),
+    epayoutsFieldFontSize: pickEnum(
+      root["epayoutsFieldFontSize"],
+      CARD_FIELD_FONT_SIZES,
+      pickEnum(
+        root["paypalFieldFontSize"],
+        CARD_FIELD_FONT_SIZES,
+        dflt.epayoutsFieldFontSize
+      )
+    ),
+    epayoutsFieldWeight: pickEnum(
+      root["epayoutsFieldWeight"],
+      CARD_FIELD_WEIGHTS,
+      pickEnum(
+        root["paypalFieldWeight"],
+        CARD_FIELD_WEIGHTS,
+        dflt.epayoutsFieldWeight
+      )
+    ),
+    epayoutsFocusRing: pickEnum(
+      root["epayoutsFocusRing"],
+      CARD_FOCUS_RINGS,
+      pickEnum(root["paypalFocusRing"], CARD_FOCUS_RINGS, dflt.epayoutsFocusRing)
+    ),
+    epayoutsValidTint: parseBool(
+      root["epayoutsValidTint"],
+      parseBool(root["paypalValidTint"], dflt.epayoutsValidTint)
+    ),
     nomupayFormStyle: pickEnum(
       root["nomupayFormStyle"],
       NOMUPAY_FORM_STYLES,
@@ -13805,6 +14462,9 @@ export {
   Settings,
   MessageTemplates,
   Risk,
+  LiveEventStream,
+  openLiveStream,
+  Live,
   Delopay,
   leaf,
   allOf,
@@ -14022,4 +14682,4 @@ export {
   decodeNativePanes,
   encodeNativePanes
 };
-//# sourceMappingURL=chunk-R6E57AD4.js.map
+//# sourceMappingURL=chunk-5FGSME7D.js.map