@bizjaya/finclient 0.0.0-stage → 0.2.0

package/dist/index.cjs

@@ -0,0 +1,727 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AccountsResource: () => AccountsResource,
+  ChangesResource: () => ChangesResource,
+  FinApiError: () => FinApiError,
+  FinClient: () => FinClient,
+  FinHttpTransport: () => FinHttpTransport,
+  FxResource: () => FxResource,
+  OrdersResource: () => OrdersResource,
+  WebhooksResource: () => WebhooksResource,
+  readAllChanges: () => readAllChanges,
+  readChangePages: () => readChangePages
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/change-feed.ts
+async function* readChangePages(readPage, cursor, signal) {
+  const seen = /* @__PURE__ */ new Set();
+  if (cursor) seen.add(cursor);
+  for (; ; ) {
+    if (signal?.aborted) throw signal.reason;
+    const page = await readPage(cursor, signal);
+    yield page;
+    if (!page.More) return;
+    if (!page.Cursor || page.Cursor === cursor || seen.has(page.Cursor)) {
+      throw new Error("The FinCopy change feed returned More without a new cursor.");
+    }
+    seen.add(page.Cursor);
+    cursor = page.Cursor;
+  }
+}
+async function* readAllChanges(readPage, cursor, signal) {
+  for await (const page of readChangePages(readPage, cursor, signal)) {
+    for (const change of page.Changes ?? []) yield change;
+  }
+}
+
+// src/api-error.ts
+var FinApiError = class extends Error {
+  /** The HTTP status code returned by the API, or 0 when no response arrived (timeout or network failure). */
+  statusCode;
+  /** The FinCopy response code, when present. */
+  code;
+  /** Validation and service errors returned by the API. */
+  errors;
+  /** Set by the SDK for timeouts, network failures, rate limits and malformed responses; null for other API errors. */
+  errorCode;
+  /** How long the API asked the caller to wait (the Retry-After header), in milliseconds, when it said. */
+  retryAfterMs;
+  constructor(statusCode, message, code = null, errors = [], details = {}) {
+    super(message || "The FinCopy API request failed.", details.cause === void 0 ? void 0 : { cause: details.cause });
+    this.name = "FinApiError";
+    this.statusCode = statusCode;
+    this.code = code;
+    this.errors = errors;
+    this.errorCode = details.errorCode ?? null;
+    this.retryAfterMs = details.retryAfterMs ?? null;
+  }
+};
+
+// src/sse.ts
+var FinSseParser = class {
+  eventName = null;
+  data = [];
+  /** Adds one line (without its line break). Returns the event the line completed, if any. */
+  add(line) {
+    if (!line) return this.flush();
+    if (line.startsWith(":")) return null;
+    const separator = line.indexOf(":");
+    const field = separator < 0 ? line : line.slice(0, separator);
+    const value = separator < 0 ? "" : line.slice(separator + 1).replace(/^ /, "");
+    if (field === "event") this.eventName = value;
+    else if (field === "data") this.data.push(value);
+    return null;
+  }
+  /** Ends the stream: an event still being read is returned when it carries data. */
+  complete() {
+    return this.data.length ? this.flush() : null;
+  }
+  flush() {
+    const item = this.data.length ? { event: this.eventName ?? "message", data: this.data.join("\n") } : null;
+    this.eventName = null;
+    this.data = [];
+    return item;
+  }
+};
+
+// src/http-transport.ts
+var retryableStatuses = /* @__PURE__ */ new Set([429, 502, 503, 504]);
+var writeMethods = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH", "DELETE"]);
+var FinHttpTransport = class {
+  apiKey;
+  baseUrl;
+  credentials;
+  timeoutMs;
+  maxRetries;
+  fetcher;
+  delay;
+  random;
+  constructor(options) {
+    this.apiKey = options.apiKey?.trim() ?? "";
+    if (!this.apiKey && !options.fetch) throw new TypeError("apiKey is required unless a custom fetch authenticates the member session.");
+    this.baseUrl = (options.baseUrl ?? "https://api.fincopy.pro").replace(/\/+$/, "");
+    const base = new URL(this.baseUrl);
+    if (!/^https?:$/.test(base.protocol) || base.search || base.hash) {
+      throw new TypeError("baseUrl must be an absolute HTTP or HTTPS URL without a query or fragment.");
+    }
+    this.timeoutMs = options.timeoutMs ?? 3e4;
+    this.maxRetries = options.maxRetries ?? 3;
+    if (!Number.isFinite(this.timeoutMs) || this.timeoutMs <= 0) throw new RangeError("timeoutMs must be positive.");
+    if (!Number.isInteger(this.maxRetries) || this.maxRetries < 0) throw new RangeError("maxRetries cannot be negative.");
+    this.fetcher = options.fetch ?? globalThis.fetch.bind(globalThis);
+    this.credentials = options.credentials ?? (this.apiKey ? "same-origin" : "include");
+    this.delay = options.retryDelay ?? ((milliseconds, signal) => new Promise((resolve, reject) => {
+      if (signal?.aborted) {
+        reject(signal.reason);
+        return;
+      }
+      const onAbort = () => {
+        clearTimeout(timer);
+        reject(signal?.reason);
+      };
+      const timer = setTimeout(() => {
+        signal?.removeEventListener("abort", onAbort);
+        resolve();
+      }, milliseconds);
+      signal?.addEventListener("abort", onAbort, { once: true });
+      if (signal?.aborted) onAbort();
+    }));
+    this.random = options.random ?? Math.random;
+  }
+  async request(method, path, body, requestOptions = {}) {
+    const envelope = await this.sendEnvelope(method, path, body, requestOptions);
+    return envelope.data;
+  }
+  async sendEnvelope(method, path, body, requestOptions = {}) {
+    const verb = method.toUpperCase();
+    const writes = writeMethods.has(verb);
+    const bodyText = body === void 0 ? void 0 : JSON.stringify(body, (_key, value) => value === null ? void 0 : value);
+    const idempotencyKey = writes ? idempotencyKeyOf(requestOptions.idempotencyKey) : void 0;
+    const url = new URL(path.replace(/^\//, ""), `${this.baseUrl}/`);
+    for (let retry = 0; ; retry++) {
+      if (requestOptions.signal?.aborted) throw requestOptions.signal.reason;
+      const controller = new AbortController();
+      const onAbort = () => controller.abort(requestOptions.signal?.reason);
+      requestOptions.signal?.addEventListener("abort", onAbort, { once: true });
+      if (requestOptions.signal?.aborted) onAbort();
+      let timedOut = false;
+      const timer = setTimeout(() => {
+        timedOut = true;
+        controller.abort(new Error("FinCopy request timed out."));
+      }, this.timeoutMs);
+      let response;
+      let raw;
+      try {
+        const headers = new Headers({ Accept: "application/json" });
+        if (this.apiKey) headers.set("X-Api-Key", this.apiKey);
+        if (bodyText !== void 0) headers.set("Content-Type", "application/json");
+        if (idempotencyKey !== void 0) headers.set("Idempotency-Key", idempotencyKey);
+        response = await this.fetcher(url, {
+          method: verb,
+          headers,
+          body: bodyText,
+          signal: controller.signal,
+          credentials: this.credentials
+        });
+        raw = await response.text();
+      } catch (error) {
+        if (requestOptions.signal?.aborted) throw error;
+        if (retry >= this.maxRetries) {
+          throw timedOut ? new FinApiError(0, "The FinCopy API did not answer in time.", null, [], { errorCode: "timeout", cause: error }) : new FinApiError(0, "The FinCopy API could not be reached.", null, [], { errorCode: "network", cause: error });
+        }
+        await this.pause(this.backoff(retry), requestOptions.signal);
+        continue;
+      } finally {
+        clearTimeout(timer);
+        requestOptions.signal?.removeEventListener("abort", onAbort);
+      }
+      const serverWait = retryAfterMsOf(response.headers.get("Retry-After"));
+      if (retryableStatuses.has(response.status)) {
+        if (retry < this.maxRetries && (serverWait === null || serverWait <= maxServerRetryAfterMs)) {
+          await this.pause(serverWait ?? (response.status === 429 ? rateLimitBackoff(retry) : this.backoff(retry)), requestOptions.signal);
+          continue;
+        }
+      }
+      let envelope = null;
+      try {
+        envelope = raw ? JSON.parse(raw) : null;
+      } catch {
+      }
+      if (!response.ok || !envelope || envelope.isOk !== true) {
+        const fallback = `The FinCopy API request failed with HTTP ${response.status}.`;
+        const message = typeof envelope?.message === "string" && envelope.message ? envelope.message : fallback;
+        const errorCode = response.status === 429 ? "rate_limited" : response.ok ? "invalid_response" : null;
+        throw new FinApiError(
+          response.status,
+          message,
+          envelope?.code ?? null,
+          errorsOf(envelope?.errors),
+          { errorCode, retryAfterMs: serverWait }
+        );
+      }
+      if (!Object.prototype.hasOwnProperty.call(envelope, "data") || envelope.data === null) {
+        throw new FinApiError(
+          response.status,
+          "The FinCopy API returned an empty response.",
+          envelope.code ?? null,
+          errorsOf(envelope.errors),
+          { errorCode: "empty_response" }
+        );
+      }
+      return envelope;
+    }
+  }
+  async requestPage(method, path, requestOptions = {}) {
+    const envelope = await this.sendEnvelope(method, path, void 0, requestOptions);
+    if (!Array.isArray(envelope.data)) {
+      throw new FinApiError(200, "The FinCopy API returned an invalid page.", envelope.code ?? null, envelope.errors ?? []);
+    }
+    return {
+      items: envelope.data,
+      paging: envelope.paging ?? null,
+      code: envelope.code ?? 200,
+      isOk: true,
+      message: envelope.message ?? null,
+      errors: envelope.errors ?? [],
+      chksum: envelope.chksum ?? null
+    };
+  }
+  /** Reads the event stream until the server closes it or the caller aborts. It does not reconnect. */
+  async *requestEvents(path, requestOptions = {}) {
+    const url = new URL(path.replace(/^\//, ""), `${this.baseUrl}/`);
+    const headers = new Headers({ Accept: "text/event-stream" });
+    if (this.apiKey) headers.set("X-Api-Key", this.apiKey);
+    let response;
+    try {
+      response = await this.fetcher(url, {
+        method: "GET",
+        headers,
+        signal: requestOptions.signal,
+        credentials: this.credentials
+      });
+    } catch (error) {
+      if (requestOptions.signal?.aborted) throw error;
+      throw new FinApiError(0, "The FinCopy event stream could not be opened.", null, [], { errorCode: "network", cause: error });
+    }
+    if (!response.ok) {
+      const raw = await response.text();
+      let envelope = null;
+      try {
+        envelope = raw ? JSON.parse(raw) : null;
+      } catch {
+      }
+      const fallback = `The FinCopy API request failed with HTTP ${response.status}.`;
+      throw new FinApiError(
+        response.status,
+        envelope?.message || fallback,
+        envelope?.code ?? null,
+        errorsOf(envelope?.errors),
+        {
+          errorCode: response.status === 429 ? "rate_limited" : null,
+          retryAfterMs: retryAfterMsOf(response.headers.get("Retry-After"))
+        }
+      );
+    }
+    if (!response.body) throw new FinApiError(response.status, "The FinCopy API returned an empty event stream.", null, [], { errorCode: "empty_response" });
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    const parser = new FinSseParser();
+    let buffer = "";
+    try {
+      while (true) {
+        if (requestOptions.signal?.aborted) throw requestOptions.signal.reason;
+        let next;
+        try {
+          next = await reader.read();
+        } catch (error) {
+          if (requestOptions.signal?.aborted) throw error;
+          throw new FinApiError(0, "The FinCopy event stream was interrupted.", null, [], { errorCode: "network", cause: error });
+        }
+        buffer += decoder.decode(next.value, { stream: !next.done });
+        const lines = buffer.split(/\r?\n/);
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          const item = parser.add(line);
+          if (item) yield item;
+        }
+        if (next.done) {
+          if (buffer) {
+            const item = parser.add(buffer);
+            if (item) yield item;
+          }
+          const final = parser.complete();
+          if (final) yield final;
+          return;
+        }
+      }
+    } finally {
+      await reader.cancel().catch(() => void 0);
+      reader.releaseLock();
+    }
+  }
+  backoff(retry) {
+    return Math.min(maxBackoffMs, 250 * 2 ** retry * (0.75 + this.random() * 0.5));
+  }
+  async pause(milliseconds, signal) {
+    if (signal?.aborted) throw signal.reason;
+    if (milliseconds > 0) await this.delay(milliseconds, signal);
+  }
+};
+var maxServerRetryAfterMs = 6e4;
+var maxBackoffMs = 3e4;
+function rateLimitBackoff(retry) {
+  return Math.min(maxBackoffMs, Math.max(1e3, 1e3 * 2 ** retry));
+}
+function retryAfterMsOf(header) {
+  const value = header?.trim();
+  if (!value) return null;
+  if (/^\d+$/.test(value)) return Number(value) * 1e3;
+  const at = Date.parse(value);
+  if (Number.isNaN(at)) return null;
+  const wait = at - Date.now();
+  return wait > 0 ? wait : null;
+}
+function errorsOf(errors) {
+  return Array.isArray(errors) ? errors.map((error) => typeof error === "string" ? error : JSON.stringify(error)) : [];
+}
+function idempotencyKeyOf(supplied) {
+  const key = supplied?.trim();
+  if (!key) return newIdempotencyKey();
+  if (key.length > 120 || /[\u0000-\u001f\u007f]/.test(key)) {
+    throw new TypeError("idempotencyKey must be 1-120 characters without control characters.");
+  }
+  return key;
+}
+function newIdempotencyKey() {
+  const webCrypto = globalThis.crypto;
+  if (typeof webCrypto?.randomUUID === "function") return webCrypto.randomUUID();
+  const bytes = new Uint8Array(16);
+  if (typeof webCrypto?.getRandomValues === "function") webCrypto.getRandomValues(bytes);
+  else for (let i = 0; i < bytes.length; i++) bytes[i] = Math.floor(Math.random() * 256);
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+
+// src/resources.ts
+function pageQuery(query = {}) {
+  const params = new URLSearchParams();
+  for (const key of ["PageNo", "PageSize"]) {
+    const value = query[key];
+    if (value !== void 0) params.append(key, String(value));
+  }
+  if (query.Search !== void 0) params.append("search", query.Search);
+  for (const key of ["SortBy", "SrchBy"])
+    (query[key] ?? []).forEach((clause, index) => clause.forEach((value, part) => params.append(`${key}[${index}][${part}]`, value)));
+  for (const value of query.Include ?? []) params.append("Include", value);
+  return params.toString();
+}
+function queryPath(path, page, filters = {}) {
+  const params = new URLSearchParams(pageQuery(page));
+  for (const [key, value] of Object.entries(filters)) if (value !== void 0 && value !== null) params.set(key, String(value));
+  const suffix = params.toString();
+  return suffix ? `${path}?${suffix}` : path;
+}
+function accountPath(acno) {
+  if (!Number.isSafeInteger(acno) || acno <= 0) throw new RangeError("acno must be a positive safe integer.");
+  return `v1/fxs/accounts/${acno}`;
+}
+function numericId(value, name, allowZero = true) {
+  if (!Number.isSafeInteger(value) || value < (allowZero ? 0 : 1)) throw new RangeError(`${name} is out of range.`);
+  return String(value);
+}
+function dateValue(value) {
+  return value instanceof Date ? value.toISOString() : value;
+}
+function dateFilters(query) {
+  return {
+    fromDt: query.fromDt === void 0 ? void 0 : dateValue(query.fromDt),
+    toDt: query.toDt === void 0 ? void 0 : dateValue(query.toDt)
+  };
+}
+var AccountsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Lists reachable accounts, optionally filtered by external reference. */
+  list(page = {}, externalRef, options = {}) {
+    return this.http.requestPage("GET", queryPath("v1/fxs/accounts", page, { externalRef }), options);
+  }
+  /** Adds a hosted account. */
+  make(command, options = {}) {
+    return this.http.request("POST", "v1/fxs/accounts", command, options);
+  }
+  /** Creates a demo account. */
+  makeDemo(command, options = {}) {
+    return this.http.request("POST", "v1/fxs/accounts/demo", command, options);
+  }
+  /** Reads demo availability for one platform. */
+  demoAvailability(platform, options = {}) {
+    return this.http.request("GET", queryPath("v1/fxs/accounts/demo-availability", void 0, { platform }), void 0, options);
+  }
+  /** Reads one account by ACNO. */
+  get(acno, options = {}) {
+    return this.http.request("GET", accountPath(acno), void 0, options);
+  }
+  /** Sets or clears the account's external reference. */
+  setExternalRef(acno, command, options = {}) {
+    return this.http.request("PUT", `${accountPath(acno)}/external-ref`, command, options);
+  }
+  /** Reads account settings. */
+  getSettings(acno, options = {}) {
+    return this.http.request("GET", `${accountPath(acno)}/settings`, void 0, options);
+  }
+  /** Changes account settings. */
+  patchSettings(acno, command, options = {}) {
+    return this.http.request("PATCH", `${accountPath(acno)}/settings`, command, options);
+  }
+  /** Lists pairs for one account. */
+  pairs(acno, page = {}, search, options = {}) {
+    return this.http.requestPage("GET", queryPath(`${accountPath(acno)}/pairs`, page, { search }), options);
+  }
+  /** Reads one pair by PRNO. */
+  pair(acno, prno, options = {}) {
+    return this.http.request("GET", `${accountPath(acno)}/pairs/${numericId(prno, "prno")}`, void 0, options);
+  }
+  /** Changes one pair's settings. */
+  patchPair(acno, prno, command, options = {}) {
+    return this.http.request("PATCH", `${accountPath(acno)}/pairs/${numericId(prno, "prno")}`, command, options);
+  }
+  /** Reads the broker symbols and enabled list. */
+  symbols(acno, options = {}) {
+    return this.http.request("GET", `${accountPath(acno)}/symbols`, void 0, options);
+  }
+  /** Adds or removes enabled symbols. */
+  editSymbols(acno, command, options = {}) {
+    return this.http.request("PUT", `${accountPath(acno)}/symbols`, command, options);
+  }
+  /** Reads a symbol's broker specification and latest quote. */
+  quote(acno, symbol, options = {}) {
+    if (!symbol.trim()) throw new TypeError("symbol is required.");
+    return this.http.request("GET", `${accountPath(acno)}/quotes/${encodeURIComponent(symbol)}`, void 0, options);
+  }
+  /** Lists live orders for one account. */
+  orders(acno, page = {}, search, options = {}) {
+    return this.http.requestPage("GET", queryPath(`${accountPath(acno)}/orders`, page, { search }), options);
+  }
+  /** Reads one live or settled order. */
+  order(acno, oid, options = {}) {
+    return this.http.request("GET", `${accountPath(acno)}/orders/${numericId(oid, "oid")}`, void 0, options);
+  }
+  /** Lists settled orders. */
+  history(acno, page = {}, search, options = {}) {
+    return this.http.requestPage("GET", queryPath(`${accountPath(acno)}/history`, page, { search }), options);
+  }
+  /** Reads one settled order by OID. */
+  historyItem(acno, oid, options = {}) {
+    return this.http.request("GET", `${accountPath(acno)}/history/${numericId(oid, "oid")}`, void 0, options);
+  }
+  /** Lists HYBRID DCA proposals waiting for an answer. */
+  dcaQueue(acno, options = {}) {
+    return this.http.request("GET", `${accountPath(acno)}/dca`, void 0, options);
+  }
+  /** Lists daily performance rows. */
+  performance(acno, query = {}) {
+    return this.http.request("GET", queryPath(`${accountPath(acno)}/performance`, void 0, dateFilters(query)), void 0, query);
+  }
+  /** Reads the account's performance window. */
+  performanceWindow(acno, options = {}) {
+    return this.http.request("GET", `${accountPath(acno)}/performance/window`, void 0, options);
+  }
+  /** Reads performance bars for an optional UTC date range. */
+  performanceBars(acno, query = {}) {
+    return this.http.request("GET", queryPath(`${accountPath(acno)}/performance/bars`, void 0, dateFilters(query)), void 0, query);
+  }
+  /** Lists paged account activity. */
+  activity(acno, page = {}, search, options = {}) {
+    return this.http.requestPage("GET", queryPath(`${accountPath(acno)}/activity`, page, { search }), options);
+  }
+  /** Previews applying a strategy (the account owner's or a FinCopy preset): what each symbol would change. Nothing changes. */
+  previewStrategy(acno, command, options = {}) {
+    return this.http.request("POST", `${accountPath(acno)}/strategy/preview`, command, options);
+  }
+  /** Applies a strategy to the account and its symbols; a side holding orders keeps what it must keep. */
+  applyStrategy(acno, command, options = {}) {
+    return this.http.request("POST", `${accountPath(acno)}/strategy/apply`, command, options);
+  }
+  /** Lists recent terminal operations. */
+  operations(acno, page = {}, options = {}) {
+    return this.http.requestPage("GET", queryPath(`${accountPath(acno)}/operations`, page), options);
+  }
+  /** Queues a broker-password change. */
+  changePassword(acno, command, options = {}) {
+    return this.http.request("POST", `${accountPath(acno)}/password`, command, options);
+  }
+  /** Queues a terminal start. */
+  start(acno, options = {}) {
+    return this.operation(acno, "start", options);
+  }
+  /** Queues a terminal stop. */
+  stop(acno, options = {}) {
+    return this.operation(acno, "stop", options);
+  }
+  /** Queues a terminal restart. */
+  restart(acno, options = {}) {
+    return this.operation(acno, "restart", options);
+  }
+  /** Queues account removal. */
+  remove(acno, options = {}) {
+    return this.http.request("DELETE", accountPath(acno), void 0, options);
+  }
+  operation(acno, action, options) {
+    return this.http.request("POST", `${accountPath(acno)}/${action}`, void 0, options);
+  }
+};
+var OrdersResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Preflights a trade request. */
+  preInfo(acno, command, options = {}) {
+    return this.http.request("POST", `${accountPath(acno)}/trade/preinfo`, command, options);
+  }
+  /** Sends one trade action. */
+  make(acno, command, options = {}) {
+    return this.http.request("POST", `${accountPath(acno)}/trade`, command, options);
+  }
+  /** Sends paired BUY and SELL actions. */
+  hedge(acno, command, options = {}) {
+    return this.http.request("POST", `${accountPath(acno)}/trade/hedge`, command, options);
+  }
+  /** Modifies a trade or pending order. */
+  modify(acno, command, options = {}) {
+    return this.http.request("POST", `${accountPath(acno)}/trade/modify`, command, options);
+  }
+  /** Cancels an order that has not reached the terminal. */
+  cancelWaiting(acno, command, options = {}) {
+    return this.http.request("POST", `${accountPath(acno)}/trade/cancel`, command, options);
+  }
+  /** Accepts or rejects one DCA proposal. */
+  answerDca(acno, oid, command, options = {}) {
+    return this.http.request("POST", `${accountPath(acno)}/dca/${numericId(oid, "oid")}`, command, options);
+  }
+};
+var FxResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Lists pairs across reachable accounts. */
+  pairs(query = {}, options = {}) {
+    return this.http.requestPage("GET", listPath("v1/fxs/pairs", query), options);
+  }
+  /** Lists open orders across reachable accounts. */
+  orders(query = {}, options = {}) {
+    return this.http.requestPage("GET", listPath("v1/fxs/orders", query), options);
+  }
+  /** Lists settled orders across reachable accounts. */
+  history(query = {}, options = {}) {
+    return this.http.requestPage("GET", listPath("v1/fxs/history", query), options);
+  }
+  /** Lists activity across reachable accounts. */
+  activity(query = {}, options = {}) {
+    return this.http.requestPage("GET", listPath("v1/fxs/activity", query), options);
+  }
+  /** HYBRID DCA proposals waiting for an answer across reachable accounts, newest first. */
+  dca(acno, options = {}) {
+    return this.http.request("GET", queryPath("v1/fxs/dca", void 0, { acno }), void 0, options);
+  }
+  /** The newest terminal operations across reachable accounts. */
+  operations(page = {}, acno, options = {}) {
+    return this.http.requestPage("GET", queryPath("v1/fxs/operations", page, { acno }), options);
+  }
+  /** The last 30 days by currency book across reachable accounts. */
+  performanceWindow(query = {}) {
+    return this.http.request("GET", queryPath("v1/fxs/performance/window", void 0, { acno: query.acno, demo: query.demo }), void 0, query);
+  }
+  /** Daily performance bars across reachable accounts for an optional UTC date range. */
+  performanceBars(query = {}) {
+    return this.http.request("GET", queryPath(
+      "v1/fxs/performance/bars",
+      void 0,
+      { acno: query.acno, demo: query.demo, ...dateFilters(query) }
+    ), void 0, query);
+  }
+  /** Lists the strategies you can apply: your own and FinCopy's presets; with `acno`, that account owner's. */
+  strategies(acno, options = {}) {
+    return this.http.request("GET", queryPath("v1/fxs/strategies", void 0, { acno }), void 0, options);
+  }
+  /** Reads one strategy. */
+  strategy(isno, options = {}) {
+    return this.http.request("GET", strategyPath(isno), void 0, options);
+  }
+  /** Creates one of your own strategies. */
+  makeStrategy(command, options = {}) {
+    return this.http.request("POST", "v1/fxs/strategies", command, options);
+  }
+  /** Changes one of your own strategies; fields left unset keep their values. */
+  patchStrategy(isno, command, options = {}) {
+    return this.http.request("PATCH", strategyPath(isno), command, options);
+  }
+  /** Deletes one of your own strategies. */
+  deleteStrategy(isno, options = {}) {
+    return this.http.request("DELETE", strategyPath(isno), void 0, options);
+  }
+  /** Reads the signals shown for enabled symbols. */
+  signals(options = {}) {
+    return this.http.request("GET", "v1/fxs/signals", void 0, options);
+  }
+  /** Lists warning and error activity. */
+  alerts(page = {}, options = {}) {
+    return this.http.requestPage("GET", queryPath("v1/fxs/alerts", page), options);
+  }
+  /**
+   * Opens the live event stream for reachable accounts. It does not reconnect: it ends when the server closes it (about
+   * every 30 minutes) or the connection breaks, so open it again in a loop, waiting a few seconds between attempts.
+   */
+  stream(options = {}) {
+    return this.http.requestEvents("v1/fxs/stream", options);
+  }
+  /** Searches broker servers available when adding an account. */
+  brokers(query, platform, demosOnly, options = {}) {
+    return this.http.request("GET", queryPath("v1/brokers", void 0, { Q: query, Platform: platform, DemosOnly: demosOnly }), void 0, options);
+  }
+};
+var ChangesResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Reads one changes page using an optional cursor. */
+  get(cursor, take = 500, options = {}) {
+    if (!Number.isInteger(take) || take < 1 || take > 1e3) throw new RangeError("take must be between 1 and 1000.");
+    return this.http.request("GET", queryPath("v1/changes", void 0, { cursor, take }), void 0, options);
+  }
+  /** Reads changes page by page, following each cursor. */
+  readPages(cursor, take = 500, signal) {
+    return readChangePages((next, nextSignal) => this.page(next, take, nextSignal), cursor, signal);
+  }
+  /** Streams all available changes. Use readPages to retain a resume cursor. */
+  readAll(cursor, take = 500, signal) {
+    return readAllChanges((next, nextSignal) => this.page(next, take, nextSignal), cursor, signal);
+  }
+  async page(cursor, take, signal) {
+    const page = await this.get(cursor, take, { signal });
+    return { Changes: page.Changes ?? [], Cursor: page.Cursor ?? null, More: page.More ?? false };
+  }
+};
+var WebhooksResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Reads this key's webhook configuration. */
+  get(options = {}) {
+    return this.http.request("GET", "v1/webhook", void 0, options);
+  }
+  /** Sets the webhook destination and returns its signing secret once. */
+  set(command, options = {}) {
+    return this.http.request("PUT", "v1/webhook", command, options);
+  }
+  /** Removes this key's webhook. */
+  delete(options = {}) {
+    return this.http.request("DELETE", "v1/webhook", void 0, options);
+  }
+  /** Sends a signed test delivery. */
+  ping(options = {}) {
+    return this.http.request("POST", "v1/webhook/ping", void 0, options);
+  }
+};
+function strategyPath(isno) {
+  return `v1/fxs/strategies/${numericId(isno, "isno")}`;
+}
+function listPath(path, query) {
+  return queryPath(path, query.page, { acno: query.acno, prno: query.prno, demo: query.demo, platform: query.platform, search: query.search });
+}
+
+// src/client.ts
+var FinClient = class {
+  copy;
+  constructor(options) {
+    const transport = new FinHttpTransport(options);
+    this.copy = {
+      accounts: new AccountsResource(transport),
+      orders: new OrdersResource(transport),
+      fx: new FxResource(transport),
+      changes: new ChangesResource(transport),
+      webhooks: new WebhooksResource(transport)
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AccountsResource,
+  ChangesResource,
+  FinApiError,
+  FinClient,
+  FinHttpTransport,
+  FxResource,
+  OrdersResource,
+  WebhooksResource,
+  readAllChanges,
+  readChangePages
+});