@bizjaya/finclient 0.1.1 → 0.2.1

package/dist/index.js

@@ -20,9 +20,6 @@ async function* readAllChanges(readPage, cursor, signal) {
   }
 }
 
-// src/http-transport.ts
-import { randomUUID } from "crypto";
-
 // 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). */
@@ -46,20 +43,48 @@ var FinApiError = class extends Error {
   }
 };
 
+// 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) {
-    if (!options.apiKey?.trim()) throw new TypeError("apiKey is required.");
-    this.apiKey = options.apiKey;
+    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.io").replace(/\/+$/, "");
     const base = new URL(this.baseUrl);
     if (!/^https?:$/.test(base.protocol) || base.search || base.hash) {
@@ -70,6 +95,7 @@ var FinHttpTransport = class {
     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);
@@ -112,14 +138,16 @@ var FinHttpTransport = class {
       let response;
       let raw;
       try {
-        const headers = new Headers({ "X-Api-Key": this.apiKey, Accept: "application/json" });
+        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
+          signal: controller.signal,
+          credentials: this.credentials
         });
         raw = await response.text();
       } catch (error) {
@@ -184,6 +212,79 @@ var FinHttpTransport = class {
       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));
   }
@@ -211,128 +312,194 @@ function errorsOf(errors) {
 }
 function idempotencyKeyOf(supplied) {
   const key = supplied?.trim();
-  if (!key) return randomUUID();
+  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();
-  const scalarKeys = ["PageNo", "PageSize", "PageOff", "IsAsc", "SortCol", "SortDir", "SrchCol", "SrchVal"];
-  for (const key of scalarKeys) {
-    const value2 = query[key];
-    if (value2 !== void 0) params.append(key, String(value2));
+  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", "Include"]) {
-    for (const value2 of query[key] ?? []) params.append(key, value2);
-  }
-  const value = params.toString();
-  return value ? `?${value}` : "";
+  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(accountId) {
-  if (!accountId?.trim()) throw new TypeError("accountId is required.");
-  return `v1/accounts/${encodeURIComponent(accountId)}`;
+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) {
-  if (!Number.isSafeInteger(value) || value < 0) throw new RangeError(`${name} must be a non-negative safe integer.`);
+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 dateQuery(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 the accounts this API key can reach. */
-  list(options = {}) {
-    return this.http.request("GET", "v1/accounts", void 0, options);
+  /** 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 for the key's owner. */
+  /** Adds a hosted account. */
   make(command, options = {}) {
-    return this.http.request("POST", "v1/accounts/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 one account and its latest state. */
-  get(accountId, options = {}) {
-    return this.http.request("GET", accountPath(accountId), void 0, 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(accountId, command, options = {}) {
-    return this.http.request("PUT", `${accountPath(accountId)}/external-ref`, command, options);
+  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);
   }
-  /** Reads the account's trading settings. */
-  getTrading(accountId, options = {}) {
-    return this.http.request("GET", `${accountPath(accountId)}/fxs`, 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);
   }
-  /** Changes the account's trading settings. */
-  patchTrading(accountId, command, options = {}) {
-    return this.http.request("PATCH", `${accountPath(accountId)}/fxs`, command, options);
+  /** Reads the broker symbols and enabled list. */
+  symbols(acno, options = {}) {
+    return this.http.request("GET", `${accountPath(acno)}/symbols`, void 0, options);
   }
-  /** Lists the account's symbols and their BUY and SELL books. */
-  listPairs(accountId, query = {}, options = {}) {
-    return this.http.requestPage("GET", `${accountPath(accountId)}/pairs${pageQuery(query)}`, options);
+  /** Adds or removes enabled symbols. */
+  editSymbols(acno, command, options = {}) {
+    return this.http.request("PUT", `${accountPath(acno)}/symbols`, command, options);
   }
-  /** Reads one symbol and its settings. */
-  getPair(accountId, prno, options = {}) {
-    return this.http.request("GET", `${accountPath(accountId)}/pairs/${numericId(prno, "prno")}`, void 0, 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);
   }
-  /** Changes one symbol's settings. */
-  patchPair(accountId, prno, command, options = {}) {
-    return this.http.request("PATCH", `${accountPath(accountId)}/pairs/${numericId(prno, "prno")}`, command, 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(accountId, options = {}) {
-    return this.http.request("GET", `${accountPath(accountId)}/dca-queue`, void 0, options);
+  dcaQueue(acno, options = {}) {
+    return this.http.request("GET", `${accountPath(acno)}/dca`, void 0, options);
   }
-  /** Reads broker symbols and the account's enabled symbols. */
-  symbols(accountId, options = {}) {
-    return this.http.request("GET", `${accountPath(accountId)}/symbols`, 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);
   }
-  /** Adds and removes symbols from the account's enabled list. */
-  editSymbols(accountId, command, options = {}) {
-    return this.http.request("PUT", `${accountPath(accountId)}/symbols`, command, options);
+  /** Reads the account's performance window. */
+  performanceWindow(acno, options = {}) {
+    return this.http.request("GET", `${accountPath(acno)}/performance/window`, void 0, options);
   }
-  /** Reads a symbol's broker specification and latest quote. */
-  quote(accountId, symbol, options = {}) {
-    if (!symbol?.trim()) throw new TypeError("symbol is required.");
-    return this.http.request("GET", `${accountPath(accountId)}/quotes/${encodeURIComponent(symbol)}`, void 0, options);
-  }
-  /** Reads daily performance rows for one account and optional UTC date range. */
-  performance(accountId, query = {}) {
-    const params = new URLSearchParams();
-    if (query.fromDt !== void 0) params.set("fromDt", dateQuery(query.fromDt));
-    if (query.toDt !== void 0) params.set("toDt", dateQuery(query.toDt));
-    const encoded = params.toString();
-    const suffix = encoded ? `?${encoded}` : "";
-    return this.http.request("GET", `${accountPath(accountId)}/performance${suffix}`, void 0, query);
-  }
-  /** Reads recent activity for one account. */
-  activity(accountId, options = {}) {
-    return this.http.request("GET", `${accountPath(accountId)}/activity`, void 0, options);
-  }
-  /** Queues a start operation for the hosted terminal. */
-  start(accountId, options = {}) {
-    return this.operation(accountId, "start", options);
-  }
-  /** Queues a stop operation for the hosted terminal. */
-  stop(accountId, options = {}) {
-    return this.operation(accountId, "stop", options);
-  }
-  /** Queues a restart operation for the hosted terminal. */
-  restart(accountId, options = {}) {
-    return this.operation(accountId, "restart", options);
-  }
-  /** Queues removal of the hosted account and its terminal. */
-  remove(accountId, options = {}) {
-    return this.operation(accountId, "remove", options);
-  }
-  operation(accountId, operation, options) {
-    return this.http.request("POST", `${accountPath(accountId)}/${operation}`, 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);
+  }
+  remove(acno, commandOrOptions = {}, options = {}) {
+    const hasCommand = Object.prototype.hasOwnProperty.call(commandOrOptions, "TrPin");
+    const command = hasCommand ? commandOrOptions : { TrPin: null };
+    const requestOptions = hasCommand ? options : commandOrOptions;
+    return this.http.request("DELETE", accountPath(acno), command, requestOptions);
+  }
+  operation(acno, action, options) {
+    return this.http.request("POST", `${accountPath(acno)}/${action}`, void 0, options);
   }
 };
 var OrdersResource = class {
@@ -340,45 +507,110 @@ var OrdersResource = class {
     this.http = http;
   }
   http;
-  /** Lists live, queued and pending orders. */
-  list(accountId, query = {}, options = {}) {
-    return this.http.requestPage("GET", `${accountPath(accountId)}/orders${pageQuery(query)}`, options);
+  /** Preflights a trade request. */
+  preInfo(acno, command, options = {}) {
+    return this.http.request("POST", `${accountPath(acno)}/trade/preinfo`, command, options);
   }
-  /** Lists settled orders, newest first. */
-  history(accountId, query = {}, options = {}) {
-    return this.http.requestPage("GET", `${accountPath(accountId)}/orders/history${pageQuery(query)}`, options);
+  /** Sends one trade action. */
+  make(acno, command, options = {}) {
+    return this.http.request("POST", `${accountPath(acno)}/trade`, command, options);
   }
-  /** Reads one settled order. */
-  historyItem(accountId, oid, options = {}) {
-    return this.http.request("GET", `${accountPath(accountId)}/orders/history/${numericId(oid, "oid")}`, void 0, options);
+  /** Sends paired BUY and SELL actions. */
+  hedge(acno, command, options = {}) {
+    return this.http.request("POST", `${accountPath(acno)}/trade/hedge`, command, options);
   }
-  /** Reads one live or settled order. */
-  get(accountId, oid, options = {}) {
-    return this.http.request("GET", `${accountPath(accountId)}/orders/${numericId(oid, "oid")}`, void 0, options);
+  /** Modifies a trade or pending order. */
+  modify(acno, command, options = {}) {
+    return this.http.request("POST", `${accountPath(acno)}/trade/modify`, command, options);
   }
-  /** Sends one FXS action. A successful response means queued for the terminal, not filled. */
-  make(accountId, command, options = {}) {
-    return this.http.request("POST", `${accountPath(accountId)}/orders`, 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 HYBRID DCA proposal. */
-  answerDca(accountId, oid, command, options = {}) {
-    return this.http.request("POST", `${accountPath(accountId)}/dca/${numericId(oid, "oid")}/answer`, 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);
   }
-  /** Reads the quote, limits, books and settings used by the trade ticket. */
-  preInfo(accountId, command, options = {}) {
-    return this.http.request("POST", `${accountPath(accountId)}/orders/preinfo`, command, options);
+};
+var FxResource = class {
+  constructor(http) {
+    this.http = http;
   }
-  /** Sends a BUY and SELL trade together. A successful response means queued, not filled. */
-  hedge(accountId, command, options = {}) {
-    return this.http.request("POST", `${accountPath(accountId)}/orders/hedge`, command, options);
+  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);
   }
-  /** Changes an order's TP field, SL field, expiry or pending price. */
-  modify(accountId, command, options = {}) {
-    return this.http.request("POST", `${accountPath(accountId)}/trades/modify`, command, 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);
   }
-  /** Cancels an order that has not yet been delivered to the terminal. */
-  cancelWaiting(accountId, command, options = {}) {
-    return this.http.request("POST", `${accountPath(accountId)}/trades/cancel-waiting`, command, 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 {
@@ -389,18 +621,13 @@ var ChangesResource = class {
   /** 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.");
-    const params = new URLSearchParams({ take: String(take) });
-    if (cursor) params.set("cursor", cursor);
-    return this.http.request("GET", `v1/accounts/changes?${params}`, void 0, options);
+    return this.http.request("GET", queryPath("v1/changes", void 0, { cursor, take }), void 0, options);
   }
-  /**
-   * Streams the available changes page by page, following each returned cursor. Save each page's `Cursor` after handling
-   * its `Changes`, so a restart resumes from there.
-   */
+  /** 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 every currently available change, following each returned cursor. Use `readPages` to save the cursor. */
+  /** 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);
   }
@@ -416,21 +643,27 @@ var WebhooksResource = class {
   http;
   /** Reads this key's webhook configuration. */
   get(options = {}) {
-    return this.http.request("GET", "v1/accounts/webhook", void 0, options);
+    return this.http.request("GET", "v1/webhook", void 0, options);
   }
-  /** Sets the HTTPS destination and returns its signing secret once. */
+  /** Sets the webhook destination and returns its signing secret once. */
   set(command, options = {}) {
-    return this.http.request("PUT", "v1/accounts/webhook", command, options);
+    return this.http.request("PUT", "v1/webhook", command, options);
   }
   /** Removes this key's webhook. */
   delete(options = {}) {
-    return this.http.request("DELETE", "v1/accounts/webhook", void 0, options);
+    return this.http.request("DELETE", "v1/webhook", void 0, options);
   }
-  /** Sends a signed test POST to this key's webhook. */
+  /** Sends a signed test delivery. */
   ping(options = {}) {
-    return this.http.request("POST", "v1/accounts/webhook/ping", void 0, 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 {
@@ -440,40 +673,19 @@ var FinClient = class {
     this.copy = {
       accounts: new AccountsResource(transport),
       orders: new OrdersResource(transport),
+      fx: new FxResource(transport),
       changes: new ChangesResource(transport),
       webhooks: new WebhooksResource(transport)
     };
   }
 };
-
-// src/webhook.ts
-import { createHmac, timingSafeEqual } from "crypto";
-var FinWebhook = class {
-  static allowedSkewSeconds = 300;
-  /** Verify X-FinCopy-Signature over the timestamp and the exact raw request body. */
-  static verify(secret, timestamp, body, signature) {
-    if (!secret || !signature) return false;
-    const timestampText = String(timestamp);
-    if (!/^\d+$/.test(timestampText)) return false;
-    const seconds = Number(timestampText);
-    if (!Number.isSafeInteger(seconds)) return false;
-    const now = Math.floor(Date.now() / 1e3);
-    if (now - seconds > this.allowedSkewSeconds || seconds - now > this.allowedSkewSeconds) return false;
-    const suppliedHex = signature.startsWith("sha256=") ? signature.slice(7) : signature;
-    if (!/^[a-fA-F0-9]{64}$/.test(suppliedHex)) return false;
-    const supplied = Buffer.from(suppliedHex, "hex");
-    const signedBody = Buffer.isBuffer(body) ? body : Buffer.from(body);
-    const expected = createHmac("sha256", Buffer.from(secret, "utf8")).update(Buffer.from(`${timestampText}.`, "utf8")).update(signedBody).digest();
-    return supplied.length === expected.length && timingSafeEqual(supplied, expected);
-  }
-};
 export {
   AccountsResource,
   ChangesResource,
   FinApiError,
   FinClient,
   FinHttpTransport,
-  FinWebhook,
+  FxResource,
   OrdersResource,
   WebhooksResource,
   readAllChanges,