@0xmonaco/types 1.0.67 → 1.0.70

package/dist/trading/responses.d.ts

@@ -187,15 +187,7 @@ export interface GetPaginatedOrdersParams {
     tradingMode?: TradingMode;
     /** Filter by margin account UUID */
     marginAccountId?: string;
-    /**
-     * Page number for legacy offset pagination.
-     *
-     * @deprecated Use cursor pagination (`pageToken`) instead. Passing `page`
-     * selects legacy page-number mode, which only ever sees recent (hot)
-     * history; omitting both `page` and `pageToken` now drives cursor mode.
-     */
-    page?: number;
-    /** Number of orders per page (default: 10; max 100 in page-number mode, up to 1000 when `pageToken` is present) */
+    /** Number of orders per page (default: 10; max 1000) */
     pageSize?: number;
     /**
      * Pagination cursor with three distinct states:
@@ -230,13 +222,6 @@ export interface GetPaginatedOrdersResponse {
      * `totalCapped` is `true` this is a lower bound (at least this many exist).
      */
     total: number;
-    /**
-     * Current page number.
-     *
-     * @deprecated Only populated by legacy page-number (offset) responses; 0 in
-     * cursor mode. Use `pageToken`/`nextPageToken` pagination instead.
-     */
-    page: number;
     /** Number of orders per page */
     pageSize: number;
     /**
@@ -487,15 +472,7 @@ export interface ListConditionalOrdersParams {
     marginAccountId?: string;
     tradingPairId?: string;
     state?: ConditionalOrderState;
-    /**
-     * Page number for legacy offset pagination.
-     *
-     * @deprecated Use cursor pagination (`pageToken`) instead. Passing `page`
-     * selects legacy page-number mode; omitting both `page` and `pageToken`
-     * drives cursor mode.
-     */
-    page?: number;
-    /** Items per page (max 100 in page-number mode, up to 1000 when `pageToken` is present) */
+    /** Items per page (max 1000) */
     pageSize?: number;
     /**
      * Pagination cursor with three distinct states:
@@ -609,18 +586,14 @@ export interface ConditionalOrder {
      * the sequencer step that wrote it (0XM-2440). A strictly higher value is
      * strictly newer state for that conditional order.
      *
-     * Present on REST reads and on the subscribe-time `conditional_orders`
-     * snapshot frame. **Absent on live conditional events**, by design: those are
-     * emitted from a model captured before the sequencer acted, so the only value
-     * available there is the one the row held *before* the change being
-     * announced — a client merging on `>=` would let a snapshot read at that
-     * version win the tie and undo the transition.
-     *
-     * So seed conditional state from the snapshot and REST, comparing with
-     * `snapshot.version >= local.version`, and apply live events as state without
-     * ranking them. `>=` rather than `>`: one sequencer step can write several
+     * Present on REST reads, on live `conditionalOrders` updates and on the
+     * subscribe-time snapshot frame, always the version of the row described.
+     * When both sides carry one, merge with `incoming.version >= local.version`:
+     * `>=` rather than `>`, because one sequencer step can write several
      * conditional rows (a trigger writes the triggered row and cancels its OCO
-     * sibling), so equal means "same step", not identical state.
+     * sibling), so equal means "same step", not identical state. Never compare
+     * an absent version numerically: a versioned row supersedes an unversioned
+     * one, and two unversioned rows compare on `updatedAt`.
      *
      * Absent means unknown — a row last written before the field existed — never
      * zero. Wire: `version`.
@@ -648,12 +621,6 @@ export interface ListConditionalOrdersResponse {
      * cursor (`pageToken`) mode, which runs no COUNT (AIP-158).
      */
     total: number;
-    /**
-     * Current page number in legacy offset mode; `0` in cursor mode.
-     *
-     * @deprecated Use cursor pagination (`pageToken`/`nextPageToken`) instead.
-     */
-    page: number;
     pageSize: number;
     /**
      * Cursor for the next page, minted only while a further page exists (the read
@@ -918,15 +885,7 @@ export interface ListTwapOrdersParams {
     state?: TwapOrderState;
     /** Filter by trading pair UUID */
     tradingPairId?: string;
-    /**
-     * Page number for legacy offset pagination.
-     *
-     * @deprecated Use cursor pagination (`pageToken`) instead. Passing `page`
-     * selects legacy page-number mode; omitting both `page` and `pageToken`
-     * drives cursor mode.
-     */
-    page?: number;
-    /** Items per page (max 100 in page-number mode, up to 1000 when `pageToken` is present) */
+    /** Items per page (max 1000) */
     pageSize?: number;
     /**
      * Pagination cursor with three distinct states:
@@ -957,12 +916,6 @@ export interface ListTwapOrdersResponse {
      * which runs no COUNT (AIP-158).
      */
     total: number;
-    /**
-     * Current page number in legacy offset mode; `0` in cursor mode.
-     *
-     * @deprecated Use cursor pagination (`pageToken`/`nextPageToken`) instead.
-     */
-    page: number;
     /** Items per page */
     pageSize: number;
     /**

package/dist/validation/copy-trading.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Copy trading validation schemas (0XM-2851).
+ *
+ * Client-side checks for the copy trading request params, run before a
+ * request is sent. The server stays the authority on every business rule
+ * (minimum allocation, the platform's profit-share range, leader
+ * eligibility); these catch malformed input early and mirror the request
+ * shape the REST gateway accepts, which rejects unknown fields.
+ */
+import { z } from "zod";
+/** A leader's custom TraderCode handle, as used in the leader paths. */
+export declare const LeaderHandleSchema: z.ZodString;
+/** Params for registering as a lead trader or editing your profile. */
+export declare const UpsertLeadTraderSchema: z.ZodObject<{
+    shareBps: z.ZodOptional<z.ZodNumber>;
+    bio: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        ACTIVE: "ACTIVE";
+        PAUSED: "PAUSED";
+    }>>;
+    minAllocation: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * Params for following a lead trader (no `followId`) or editing one of your
+ * follows (`followId` set). An edit REPLACES the follow's settings: every
+ * optional setting left out reverts to its default, so an edit that omits
+ * `slPct` removes the stop-loss.
+ */
+export declare const UpsertFollowSchema: z.ZodObject<{
+    followId: z.ZodOptional<z.ZodUUID>;
+    leader: z.ZodOptional<z.ZodString>;
+    marginModePolicy: z.ZodOptional<z.ZodEnum<{
+        ISOLATED: "ISOLATED";
+        CROSS: "CROSS";
+        FOLLOW: "FOLLOW";
+    }>>;
+    sizingMode: z.ZodOptional<z.ZodEnum<{
+        PROPORTIONAL: "PROPORTIONAL";
+        FIXED_MARGIN: "FIXED_MARGIN";
+    }>>;
+    sizingParam: z.ZodOptional<z.ZodString>;
+    leverageMode: z.ZodOptional<z.ZodEnum<{
+        FOLLOW: "FOLLOW";
+        FIXED: "FIXED";
+    }>>;
+    fixedLeverage: z.ZodOptional<z.ZodString>;
+    allocation: z.ZodString;
+    slPct: z.ZodOptional<z.ZodString>;
+    tradingPairIds: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
+    copyExisting: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+/** Params for previewing what copying a leader's open positions would place. */
+export declare const PreviewFollowSchema: z.ZodObject<{
+    leader: z.ZodString;
+    marginModePolicy: z.ZodOptional<z.ZodEnum<{
+        ISOLATED: "ISOLATED";
+        CROSS: "CROSS";
+        FOLLOW: "FOLLOW";
+    }>>;
+    sizingMode: z.ZodOptional<z.ZodEnum<{
+        PROPORTIONAL: "PROPORTIONAL";
+        FIXED_MARGIN: "FIXED_MARGIN";
+    }>>;
+    sizingParam: z.ZodOptional<z.ZodString>;
+    leverageMode: z.ZodOptional<z.ZodEnum<{
+        FOLLOW: "FOLLOW";
+        FIXED: "FIXED";
+    }>>;
+    fixedLeverage: z.ZodOptional<z.ZodString>;
+    allocation: z.ZodString;
+    tradingPairIds: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
+}, z.core.$strict>;
+/** Params for the public leaderboard. */
+export declare const ListLeadTradersSchema: z.ZodObject<{
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    pageToken: z.ZodOptional<z.ZodString>;
+    sort: z.ZodOptional<z.ZodEnum<{
+        roi: "roi";
+        pnl: "pnl";
+        followers: "followers";
+        allocated: "allocated";
+        aum: "aum";
+        win_rate: "win_rate";
+    }>>;
+    window: z.ZodOptional<z.ZodEnum<{
+        "7d": "7d";
+        "30d": "30d";
+        "90d": "90d";
+        all: "all";
+    }>>;
+}, z.core.$strict>;
+/** Params for a leader's closed trades. */
+export declare const ListLeadTraderClosedTradesSchema: z.ZodObject<{
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    pageToken: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/** Params for your follows. */
+export declare const ListMyFollowsSchema: z.ZodObject<{
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    pageToken: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/** Params for your followers, as a leader. */
+export declare const ListMyFollowersSchema: z.ZodObject<{
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    pageToken: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type UpsertLeadTraderParams = z.input<typeof UpsertLeadTraderSchema>;
+export type UpsertFollowParams = z.input<typeof UpsertFollowSchema>;
+export type PreviewFollowParams = z.input<typeof PreviewFollowSchema>;
+export type ListLeadTradersParams = z.input<typeof ListLeadTradersSchema>;
+export type ListLeadTraderClosedTradesParams = z.input<typeof ListLeadTraderClosedTradesSchema>;
+export type ListMyFollowsParams = z.input<typeof ListMyFollowsSchema>;
+export type ListMyFollowersParams = z.input<typeof ListMyFollowersSchema>;

package/dist/validation/copy-trading.js

@@ -0,0 +1,141 @@
+/**
+ * Copy trading validation schemas (0XM-2851).
+ *
+ * Client-side checks for the copy trading request params, run before a
+ * request is sent. The server stays the authority on every business rule
+ * (minimum allocation, the platform's profit-share range, leader
+ * eligibility); these catch malformed input early and mirror the request
+ * shape the REST gateway accepts, which rejects unknown fields.
+ */
+import { z } from "zod";
+import { PositiveDecimalStringSchema, UUIDSchema } from "./trading.js";
+/** A leader's custom TraderCode handle, as used in the leader paths. */
+export const LeaderHandleSchema = z.string().trim().min(1, "leader handle is required");
+/** A decimal fraction in (0, 1], e.g. `"0.25"` for a stop-loss at a quarter of the allocation. */
+const StopLossFractionSchema = z
+    .string()
+    .trim()
+    .regex(/^\d+(\.\d+)?$/, "slPct must be a decimal fraction (e.g. '0.25')")
+    .refine((value) => {
+    const parsed = Number.parseFloat(value);
+    return parsed > 0 && parsed <= 1;
+}, "slPct must be greater than 0 and at most 1");
+/** Page size bounded to `max`, and an opaque cursor from a previous response. */
+function cursorPage(max) {
+    return {
+        pageSize: z.number().int("Page size must be an integer").min(1, "Page size must be at least 1").max(max, `Page size cannot exceed ${max}`).optional(),
+        pageToken: z.string().optional(),
+    };
+}
+/** Params for registering as a lead trader or editing your profile. */
+export const UpsertLeadTraderSchema = z
+    .object({
+    /** Profit share in basis points; omitted keeps the current share (the platform default on a registration). */
+    shareBps: z.number().int("shareBps must be an integer").min(0, "shareBps cannot be negative").max(10000, "shareBps cannot exceed 10000").optional(),
+    /** Free-text profile description, at most 2,000 bytes; omitted clears it. */
+    bio: z
+        .string()
+        .refine((value) => new TextEncoder().encode(value).length <= 2000, "bio cannot exceed 2,000 bytes")
+        .optional(),
+    /** `ACTIVE` (default) or `PAUSED`. */
+    status: z.enum(["ACTIVE", "PAUSED"]).optional(),
+    /** Minimum follow allocation in quote units; omitted clears it. */
+    minAllocation: PositiveDecimalStringSchema.optional(),
+})
+    .strict();
+/**
+ * Params for following a lead trader (no `followId`) or editing one of your
+ * follows (`followId` set). An edit REPLACES the follow's settings: every
+ * optional setting left out reverts to its default, so an edit that omits
+ * `slPct` removes the stop-loss.
+ */
+export const UpsertFollowSchema = z
+    .object({
+    /** Omit to create a follow; set to edit one of your follows. */
+    followId: UUIDSchema.optional(),
+    /** The leader's custom TraderCode handle; required on a create, optional on an edit. */
+    leader: LeaderHandleSchema.optional(),
+    /** `FOLLOW` (default: the leader's mode per market), `CROSS` or `ISOLATED`. */
+    marginModePolicy: z.enum(["FOLLOW", "CROSS", "ISOLATED"]).optional(),
+    /** `PROPORTIONAL` (default) or `FIXED_MARGIN`. */
+    sizingMode: z.enum(["PROPORTIONAL", "FIXED_MARGIN"]).optional(),
+    /** Margin per leader order in quote units; required for `FIXED_MARGIN`, omitted otherwise. */
+    sizingParam: PositiveDecimalStringSchema.optional(),
+    /** `FOLLOW` (default: the leader's leverage) or `FIXED`. */
+    leverageMode: z.enum(["FOLLOW", "FIXED"]).optional(),
+    /** Leverage for every copy; required for `FIXED`, omitted otherwise. */
+    fixedLeverage: PositiveDecimalStringSchema.optional(),
+    /** Collateral for the copy account, in quote units, at or above the minimum. */
+    allocation: PositiveDecimalStringSchema,
+    /** Copy stop-loss as a fraction of the allocation in (0, 1]; omitted means none. */
+    slPct: StopLossFractionSchema.optional(),
+    /** Markets to copy; omit (or pass an empty list) to copy every market the leader trades. */
+    tradingPairIds: z.array(UUIDSchema).max(256, "at most 256 markets can be copied").optional(),
+    /** On a create, also copy the leader's currently open positions (see `previewFollow`). Refused on an edit. */
+    copyExisting: z.boolean().optional(),
+})
+    .strict()
+    .superRefine((params, ctx) => {
+    if (params.followId === undefined && params.leader === undefined) {
+        ctx.addIssue({ code: "custom", message: "leader is required when creating a follow", path: ["leader"] });
+    }
+    if (params.followId !== undefined && params.copyExisting === true) {
+        ctx.addIssue({ code: "custom", message: "copyExisting applies only when creating a follow", path: ["copyExisting"] });
+    }
+    termRules(params, ctx);
+});
+/** The sizing and leverage parameters are present exactly when their mode needs them. */
+function termRules(params, ctx) {
+    const fixedMargin = params.sizingMode === "FIXED_MARGIN";
+    if (fixedMargin && params.sizingParam === undefined) {
+        ctx.addIssue({ code: "custom", message: "sizingParam is required for FIXED_MARGIN sizing", path: ["sizingParam"] });
+    }
+    if (!fixedMargin && params.sizingParam !== undefined) {
+        ctx.addIssue({ code: "custom", message: "sizingParam is only accepted with FIXED_MARGIN sizing", path: ["sizingParam"] });
+    }
+    const fixedLeverage = params.leverageMode === "FIXED";
+    if (fixedLeverage && params.fixedLeverage === undefined) {
+        ctx.addIssue({ code: "custom", message: "fixedLeverage is required for FIXED leverage", path: ["fixedLeverage"] });
+    }
+    if (!fixedLeverage && params.fixedLeverage !== undefined) {
+        ctx.addIssue({ code: "custom", message: "fixedLeverage is only accepted with FIXED leverage", path: ["fixedLeverage"] });
+    }
+}
+/** Params for previewing what copying a leader's open positions would place. */
+export const PreviewFollowSchema = z
+    .object({
+    /** The leader's custom TraderCode handle. */
+    leader: LeaderHandleSchema,
+    /** `FOLLOW` (default), `CROSS` or `ISOLATED`. */
+    marginModePolicy: z.enum(["FOLLOW", "CROSS", "ISOLATED"]).optional(),
+    /** `PROPORTIONAL` (default) or `FIXED_MARGIN`. */
+    sizingMode: z.enum(["PROPORTIONAL", "FIXED_MARGIN"]).optional(),
+    /** Margin per leader order in quote units; required for `FIXED_MARGIN`, omitted otherwise. */
+    sizingParam: PositiveDecimalStringSchema.optional(),
+    /** `FOLLOW` (default) or `FIXED`. */
+    leverageMode: z.enum(["FOLLOW", "FIXED"]).optional(),
+    /** Leverage for every copy; required for `FIXED`, omitted otherwise. */
+    fixedLeverage: PositiveDecimalStringSchema.optional(),
+    /** Collateral the copy account would start with, in quote units. */
+    allocation: PositiveDecimalStringSchema,
+    /** Markets to copy; omit to copy every market the leader trades. */
+    tradingPairIds: z.array(UUIDSchema).max(256, "at most 256 markets can be copied").optional(),
+})
+    .strict()
+    .superRefine((params, ctx) => termRules(params, ctx));
+/** Params for the public leaderboard. */
+export const ListLeadTradersSchema = z
+    .object({
+    /** Metric to rank by, highest first: `roi` (default), `pnl`, `followers`, `allocated`, `aum` (marked copy account equity; leaders without it last) or `win_rate`. */
+    sort: z.enum(["roi", "pnl", "followers", "allocated", "aum", "win_rate"]).optional(),
+    /** Stats window: `7d`, `30d` (default), `90d` or `all`. */
+    window: z.enum(["7d", "30d", "90d", "all"]).optional(),
+    ...cursorPage(100),
+})
+    .strict();
+/** Params for a leader's closed trades. */
+export const ListLeadTraderClosedTradesSchema = z.object(cursorPage(100)).strict();
+/** Params for your follows. */
+export const ListMyFollowsSchema = z.object(cursorPage(1000)).strict();
+/** Params for your followers, as a leader. */
+export const ListMyFollowersSchema = z.object(cursorPage(1000)).strict();

package/dist/validation/index.d.ts

@@ -14,6 +14,7 @@
  * - Market schemas (trading pairs, candlesticks)
  */
 export * from "./common.js";
+export * from "./copy-trading.js";
 export * from "./margin-accounts.js";
 export * from "./market.js";
 export * from "./positions.js";

package/dist/validation/index.js

@@ -15,6 +15,7 @@
  */
 // Export validation utilities
 export * from "./common.js";
+export * from "./copy-trading.js";
 export * from "./margin-accounts.js";
 export * from "./market.js";
 export * from "./positions.js";

package/dist/validation/positions.d.ts

@@ -21,9 +21,9 @@ export declare const ClosePositionSchema: z.ZodObject<{
     positionId: z.ZodUUID;
     request: z.ZodObject<{
         closeType: z.ZodEnum<{
+            IOC: "IOC";
             LIMIT: "LIMIT";
             MARKET: "MARKET";
-            IOC: "IOC";
         }>;
         limitPrice: z.ZodOptional<z.ZodString>;
         slippageToleranceBps: z.ZodOptional<z.ZodNumber>;

package/dist/validation/profile.d.ts

@@ -76,7 +76,7 @@ export declare const GetUserMovementsSchema: z.ZodObject<{
  * All fields are optional — an empty object or undefined is valid.
  */
 export declare const GetUserTradesSchema: z.ZodObject<{
-    page: z.ZodOptional<z.ZodNumber>;
+    page: z.ZodOptional<z.ZodNever>;
     pageSize: z.ZodOptional<z.ZodNumber>;
     tradingPairId: z.ZodOptional<z.ZodUUID>;
     pageToken: z.ZodOptional<z.ZodString>;

package/dist/validation/profile.js

@@ -45,25 +45,17 @@ export const GetUserMovementsSchema = z.object({
  * Validates parameters for fetching paginated user trades.
  * All fields are optional — an empty object or undefined is valid.
  */
-export const GetUserTradesSchema = z
-    .object({
-    page: z.number().int("Page must be an integer").min(1, "Page must be at least 1").optional(),
+export const GetUserTradesSchema = z.object({
+    /**
+     * Rejected, not ignored. A non-strict object would let a JS or `any`
+     * caller keep passing `page`, and the SDK would then send `pageToken=""`
+     * and hand back the first cursor page on every call — the same silent
+     * duplicate-page failure the REST 400 guard exists to prevent.
+     */
+    page: z.never().optional(),
     pageSize: z.number().int("Page size must be an integer").min(1, "Page size must be at least 1").max(1000, "Page size cannot exceed 1000").optional(),
     tradingPairId: UUIDSchema.optional(),
     pageToken: z.string().optional(),
-})
-    .superRefine((params, ctx) => {
-    // The higher 1000 cap only applies to cursor (pageToken) requests; the
-    // server keeps the 100 cap for page-number requests (offset scans).
-    // Legacy page-number mode is selected only by passing `page` without
-    // `pageToken` — omitting both starts a cursor walk.
-    if (params.page !== undefined && params.pageToken === undefined && params.pageSize !== undefined && params.pageSize > 100) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: "Page size cannot exceed 100 in page-number mode (page without pageToken)",
-            path: ["pageSize"],
-        });
-    }
 });
 export const ListFundingPaymentsSchema = z.object({
     page: z.number().int("Page must be an integer").min(1, "Page must be at least 1").optional(),

package/dist/validation/trading.d.ts

@@ -332,10 +332,10 @@ export declare const ReplaceOrderSchema: z.ZodObject<{
  * Matches the getPaginatedOrders method signature which accepts:
  * - status: OrderStatus, or a non-empty array of them (optional filter)
  * - tradingPairId: trading pair UUID (optional filter)
- * - page: number (default: 1)
- * - pageSize: number (default: 10, max: 100 in page-number mode, 1000 when pageToken is present)
+ * - pageSize: number (default: 10, max: 1000)
  */
 export declare const GetPaginatedOrdersSchema: z.ZodObject<{
+    page: z.ZodOptional<z.ZodNever>;
     status: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
         SUBMITTED: "SUBMITTED";
         PARTIALLY_FILLED: "PARTIALLY_FILLED";
@@ -361,7 +361,6 @@ export declare const GetPaginatedOrdersSchema: z.ZodObject<{
         MARGIN: "MARGIN";
     }>>;
     marginAccountId: z.ZodOptional<z.ZodUUID>;
-    page: z.ZodOptional<z.ZodNumber>;
     pageSize: z.ZodOptional<z.ZodNumber>;
     pageToken: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
@@ -390,6 +389,7 @@ export declare const CancelConditionalOrderSchema: z.ZodObject<{
     conditionalOrderId: z.ZodUUID;
 }, z.core.$strip>;
 export declare const ListConditionalOrdersSchema: z.ZodObject<{
+    page: z.ZodOptional<z.ZodNever>;
     marginAccountId: z.ZodOptional<z.ZodUUID>;
     tradingPairId: z.ZodOptional<z.ZodUUID>;
     state: z.ZodOptional<z.ZodEnum<{
@@ -401,7 +401,6 @@ export declare const ListConditionalOrdersSchema: z.ZodObject<{
         TRIGGERING: "TRIGGERING";
         TRIGGERED: "TRIGGERED";
     }>>;
-    page: z.ZodOptional<z.ZodNumber>;
     pageSize: z.ZodOptional<z.ZodNumber>;
     pageToken: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
@@ -456,6 +455,7 @@ export declare const CancelTwapOrderSchema: z.ZodObject<{
     twapOrderId: z.ZodUUID;
 }, z.core.$strip>;
 export declare const ListTwapOrdersSchema: z.ZodObject<{
+    page: z.ZodOptional<z.ZodNever>;
     state: z.ZodOptional<z.ZodEnum<{
         CANCELLED: "CANCELLED";
         ACTIVE: "ACTIVE";
@@ -463,7 +463,6 @@ export declare const ListTwapOrdersSchema: z.ZodObject<{
         COMPLETED: "COMPLETED";
     }>>;
     tradingPairId: z.ZodOptional<z.ZodUUID>;
-    page: z.ZodOptional<z.ZodNumber>;
     pageSize: z.ZodOptional<z.ZodNumber>;
     pageToken: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;

package/dist/validation/trading.js

@@ -379,31 +379,22 @@ export const ReplaceOrderSchema = z.object({
  * Matches the getPaginatedOrders method signature which accepts:
  * - status: OrderStatus, or a non-empty array of them (optional filter)
  * - tradingPairId: trading pair UUID (optional filter)
- * - page: number (default: 1)
- * - pageSize: number (default: 10, max: 100 in page-number mode, 1000 when pageToken is present)
+ * - pageSize: number (default: 10, max: 1000)
  */
-export const GetPaginatedOrdersSchema = z
-    .object({
+export const GetPaginatedOrdersSchema = z.object({
+    /**
+     * Rejected, not ignored. A non-strict object would let a JS or `any`
+     * caller keep passing `page`, and the SDK would then send `pageToken=""`
+     * and hand back the first cursor page on every call — the same silent
+     * duplicate-page failure the REST 400 guard exists to prevent.
+     */
+    page: z.never().optional(),
     status: z.union([z.enum(ORDER_STATUS_VALUES), z.array(z.enum(ORDER_STATUS_VALUES)).min(1, "Status filter must list at least one status")]).optional(),
     tradingPairId: UUIDSchema.optional(),
     tradingMode: TradingModeSchema.optional(),
     marginAccountId: UUIDSchema.optional(),
-    page: z.number().int().min(1, "Page must be at least 1").optional(),
     pageSize: z.number().int().min(1, "Page size must be at least 1").max(1000, "Page size cannot exceed 1000").optional(),
     pageToken: z.string().optional(),
-})
-    .superRefine((params, ctx) => {
-    // The higher 1000 cap only applies to cursor (pageToken) requests; the
-    // server keeps the 100 cap for page-number requests (offset scans).
-    // Legacy page-number mode is selected only by passing `page` without
-    // `pageToken` — omitting both starts a cursor walk.
-    if (params.page !== undefined && params.pageToken === undefined && params.pageSize !== undefined && params.pageSize > 100) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: "Page size cannot exceed 100 in page-number mode (page without pageToken)",
-            path: ["pageSize"],
-        });
-    }
 });
 export const ConditionalOrderConditionTypeSchema = z.enum(["STOP_LOSS", "TAKE_PROFIT", "TRAILING_STOP"], {
     message: 'conditionType must be "STOP_LOSS", "TAKE_PROFIT", or "TRAILING_STOP"',
@@ -420,27 +411,19 @@ export const ClosePositionSideSchema = z.enum(["LONG", "SHORT"], {
 export const CancelConditionalOrderSchema = z.object({
     conditionalOrderId: UUIDSchema,
 });
-export const ListConditionalOrdersSchema = z
-    .object({
+export const ListConditionalOrdersSchema = z.object({
+    /**
+     * Rejected, not ignored. A non-strict object would let a JS or `any`
+     * caller keep passing `page`, and the SDK would then send `pageToken=""`
+     * and hand back the first cursor page on every call — the same silent
+     * duplicate-page failure the REST 400 guard exists to prevent.
+     */
+    page: z.never().optional(),
     marginAccountId: UUIDSchema.optional(),
     tradingPairId: UUIDSchema.optional(),
     state: ConditionalOrderStateSchema.optional(),
-    page: z.number().int().min(1, "Page must be at least 1").optional(),
     pageSize: z.number().int().min(1, "Page size must be at least 1").max(1000, "Page size cannot exceed 1000").optional(),
     pageToken: z.string().optional(),
-})
-    .superRefine((params, ctx) => {
-    // The higher 1000 cap only applies to cursor (pageToken) requests; the
-    // server keeps the 100 cap for page-number requests (offset scans).
-    // Legacy page-number mode is selected only by passing `page` without
-    // `pageToken` — omitting both starts a cursor walk.
-    if (params.page !== undefined && params.pageToken === undefined && params.pageSize !== undefined && params.pageSize > 100) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: "Page size cannot exceed 100 in page-number mode (page without pageToken)",
-            path: ["pageSize"],
-        });
-    }
 });
 export const TwapOrderStateSchema = z.enum(["PENDING", "ACTIVE", "COMPLETED", "CANCELLED"], {
     message: "Invalid TWAP order state",
@@ -564,26 +547,18 @@ export const CreateTwapOrderSchema = z
 export const CancelTwapOrderSchema = z.object({
     twapOrderId: UUIDSchema,
 });
-export const ListTwapOrdersSchema = z
-    .object({
+export const ListTwapOrdersSchema = z.object({
+    /**
+     * Rejected, not ignored. A non-strict object would let a JS or `any`
+     * caller keep passing `page`, and the SDK would then send `pageToken=""`
+     * and hand back the first cursor page on every call — the same silent
+     * duplicate-page failure the REST 400 guard exists to prevent.
+     */
+    page: z.never().optional(),
     state: TwapOrderStateSchema.optional(),
     tradingPairId: UUIDSchema.optional(),
-    page: z.number().int().min(1, "Page must be at least 1").optional(),
     pageSize: z.number().int().min(1, "Page size must be at least 1").max(1000, "Page size cannot exceed 1000").optional(),
     pageToken: z.string().optional(),
-})
-    .superRefine((params, ctx) => {
-    // The higher 1000 cap only applies to cursor (pageToken) requests; the
-    // server keeps the 100 cap for page-number requests (offset scans).
-    // Legacy page-number mode is selected only by passing `page` without
-    // `pageToken` — omitting both starts a cursor walk.
-    if (params.page !== undefined && params.pageToken === undefined && params.pageSize !== undefined && params.pageSize > 100) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: "Page size cannot exceed 100 in page-number mode (page without pageToken)",
-            path: ["pageSize"],
-        });
-    }
 });
 /**
  * Single batch create order item validation schema

package/dist/websocket/client.d.ts

@@ -52,7 +52,7 @@ import type { Interval } from "../market";
 import type { TradingMode } from "../trading";
 import type { WebSocketStatus } from "./base";
 import type { OrderbookQuotationMode } from "./clients/orderbook-client";
-import type { AccountEvent, AccountEventData, ConditionalOrderEvent, ConditionalOrderEventData, InstrumentEvent, InstrumentEventData, LiquidationEvent, LiquidationEventData, MarketStatsAllEvent, MarketStatsData, MarketStatsEvent, MarketStatsSummary, OHLCVEvent, OHLCVPriceType, OrderbookEvent, OrderEvent, PositionEvent, PositionEventData, TradeEvent, TwapOrderEvent, TwapOrderEventData, UserBalanceEvent, UserBalanceEventData, UserMovementEvent } from "./events";
+import type { AccountEvent, AccountEventData, ConditionalOrderEvent, ConditionalOrderEventData, CopyEvent, CopyRelationshipEventData, InstrumentEvent, InstrumentEventData, LiquidationEvent, LiquidationEventData, MarketStatsAllEvent, MarketStatsData, MarketStatsEvent, MarketStatsSummary, OHLCVEvent, OHLCVPriceType, OrderbookEvent, OrderEvent, PositionEvent, PositionEventData, TradeEvent, TwapOrderEvent, TwapOrderEventData, UserBalanceEvent, UserBalanceEventData, UserMovementEvent } from "./events";
 import type { OrderSnapshotItem, SnapshotHandler } from "./snapshots";
 export type MessageHandler<T> = (data: T) => void;
 export interface MonacoWebSocket {
@@ -90,6 +90,14 @@ export interface MonacoWebSocket {
     liquidations: (handler: MessageHandler<LiquidationEvent>, tradingPairId?: string, onSnapshot?: SnapshotHandler<LiquidationEventData>) => () => void;
     /** Subscribe to account-level margin health updates for the authenticated user (requires authentication) */
     account: (handler: MessageHandler<AccountEvent>, onSnapshot?: SnapshotHandler<AccountEventData>) => () => void;
+    /**
+     * Subscribe to your copy trading relationships as a follower (requires
+     * authentication): a `copy_relationship_update` frame on every change to one
+     * of your follows, and a `copy_skip` frame for every leader fill a follow
+     * could not mirror. There is no per-pair variant. `onSnapshot` receives every
+     * live follow (status `ACTIVE` or `CLOSE_ONLY`) with `change: "snapshot"`.
+     */
+    copy: (handler: MessageHandler<CopyEvent>, onSnapshot?: SnapshotHandler<CopyRelationshipEventData>) => () => void;
     /**
      * Subscribe to market lifecycle + config changes (public); omit
      * `tradingPairId` for all markets. `onSnapshot` receives the full current