@0xmonaco/types 1.0.74 → 1.0.75

package/dist/trading/orders.d.ts

@@ -3,7 +3,6 @@
  *
  * Types for trading operations and order management.
  */
-import type { ConditionalOrder, TwapOrder } from "./responses";
 /**
  * Standard order structure used across all order-related responses.
  * This represents the complete order information as returned by the API.
@@ -14,12 +13,9 @@ import type { ConditionalOrder, TwapOrder } from "./responses";
  * Orders can transition to `CANCELLED`, `REJECTED`, or `EXPIRED` at various stages.
  * Fee fields are only populated after order fills occur.
  *
- * The order listing returns every kind of order in one stream, so a row here
- * may be a book order, a TWAP parent (`orderType: "TWAP"`) or a conditional
- * order (`orderType: "CONDITIONAL"`). Switch on `orderType`: the kind-specific
- * detail hangs off `twap` / `conditional`, and the fields above are populated
- * for every kind — a parent's `quantity` is its total, `filledQuantity` what
- * it has executed so far, and `status` its state expressed as an order status.
+ * Every row is a book order: the order listing carries `LIMIT` and `MARKET`
+ * orders only. TWAP parents and conditional (TP/SL) orders are listed by
+ * `listTwapOrders` and `listConditionalOrders`, never here.
  *
  * @example
  * To calculate remaining quantity:
@@ -34,8 +30,8 @@ export interface Order {
     tradingPairId: string;
     /** Order side (BUY or SELL) */
     side: OrderSide;
-    /** What kind of order this row is - see ListedOrderType */
-    orderType: ListedOrderType;
+    /** Order type (LIMIT or MARKET) */
+    orderType: OrderType;
     /** Order status - see OrderStatus for lifecycle details */
     status: OrderStatus;
     /** Order price - null for market orders, required for limit orders */
@@ -98,18 +94,6 @@ export interface Order {
     clientOrderId?: string;
     /** Position ID linked to the order, when available */
     positionId?: string;
-    /**
-     * The TWAP parent behind this row - its schedule, slice counters and
-     * progress - present only when `orderType` is `"TWAP"`. Identical to what
-     * `getTwapOrder` returns for the same id.
-     */
-    twap?: TwapOrder;
-    /**
-     * The conditional order behind this row - its trigger and the order it fires
-     * - present only when `orderType` is `"CONDITIONAL"`. Identical to what the
-     * conditional-order endpoints return for the same id.
-     */
-    conditional?: ConditionalOrder;
     /** Stable cause when status is CANCELLED */
     terminalReason?: OrderTerminalReason;
     /**
@@ -178,7 +162,7 @@ export interface Order {
     version?: number;
 }
 /** Stable terminal causes for accepted orders that end as CANCELLED. */
-export type OrderTerminalReason = "USER_REQUESTED" | "REPLACED" | "LIQUIDATION" | "INSUFFICIENT_MARGIN" | "REDUCE_ONLY_EXHAUSTED" | "POSITION_CLOSED" | "OCO_SIBLING_TRIGGERED" | "SELF_TRADE_PREVENTION" | "AUTO_DELEVERAGING" | "SYSTEM";
+export type OrderTerminalReason = "USER_REQUESTED" | "REPLACED" | "LIQUIDATION" | "INSUFFICIENT_MARGIN" | "REDUCE_ONLY_EXHAUSTED" | "POSITION_CLOSED" | "OCO_SIBLING_TRIGGERED" | "SELF_TRADE_PREVENTION" | "AUTO_DELEVERAGING" | "PRICE_BAND" | "SLIPPAGE_TOLERANCE" | "SYSTEM";
 /**
  * Role of the creator or order
  */
@@ -201,16 +185,6 @@ export type PositionSide = "LONG" | "SHORT" | "NONE";
  * - TRAILING_STOP: Stop order that trails the market price
  */
 export type OrderType = "LIMIT" | "MARKET";
-/**
- * What kind of order a listed row is.
- *
- * Wider than {@link OrderType}, which is what you can place: the order listing
- * serves book orders, TWAP parents and conditional orders as one stream, and
- * `"TWAP"` / `"CONDITIONAL"` name the two kinds that are created through their
- * own endpoints rather than `createOrder`. A row of either kind carries its
- * detail on {@link Order.twap} or {@link Order.conditional}.
- */
-export type ListedOrderType = OrderType | "TWAP" | "CONDITIONAL";
 /**
  * Source-of-truth order status values used by runtime validation schemas.
  */

package/dist/trading/responses.d.ts

@@ -197,23 +197,18 @@ export interface GetPaginatedOrdersParams {
     /** Number of orders per page (default: 10; max 1000) */
     pageSize?: number;
     /**
-     * Pagination cursor with three distinct states:
-     * - Omitted (`undefined`): the SDK starts a cursor walk (it sends
-     *   `pageToken=""`) unless the deprecated `page` param was passed, in
-     *   which case the request uses legacy page-number pagination, limited to
-     *   recent history once the archive window is enabled.
-     * - Empty string (`""`): start a cursor walk with no prior position, from
-     *   the newest row (or the oldest, when `orderBy` is `"ASC"`).
+     * Pagination cursor with two states:
+     * - Omitted (`undefined`) or empty string (`""`): start a cursor walk with
+     *   no prior position, from the newest row (or the oldest, when `orderBy`
+     *   is `"ASC"`).
      * - Non-empty: an opaque cursor from a previous response's
      *   `nextPageToken`; results resume immediately after that position.
      *
-     * In either cursor-walk state (empty or non-empty), `page` is ignored (it
-     * comes back as 0), but `total` and `totalPages` ARE populated — bounded by
-     * the server count ceiling, see `totalCapped`. Results cover full order
-     * history — hot and archived rows merged — unlike page-number mode, which
-     * only ever sees recent history. Clients that need complete order history
-     * must use the cursor form (pass `""` to start, then follow `nextPageToken`)
-     * rather than `page`.
+     * Page-number pagination was removed (0XM-2788): there is no `page`, and
+     * sending one is a `400`. `total` and `totalPages` are still populated,
+     * bounded by the server count ceiling — see `totalCapped`. Every walk
+     * covers full order history, hot and archived rows merged. Filters and
+     * `orderBy` must match the request that minted the token.
      */
     pageToken?: string;
 }

package/dist/validation/applications.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Public application listing validation schemas
+ *
+ * The four reporting listings are cursor paged (0XM-2822). Each schema
+ * REJECTS `page` rather than omitting it: forwarding the params field by
+ * field drops a stray `page` before it reaches the wire, which means a
+ * JavaScript or `any` caller looping on `{ page: n }` would be handed the
+ * FIRST cursor page on every call and would export the same rows forever —
+ * the exact failure the REST 400 exists to surface. Validating here turns
+ * that into an immediate `ValidationError`, which is what the 400 would have
+ * done before the field-by-field forwarding hid it.
+ */
+import { z } from "zod";
+export declare const ListAppOrdersSchema: z.ZodObject<{
+    clientId: z.ZodString;
+    page: z.ZodOptional<z.ZodNever>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    pageToken: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+    userId: z.ZodOptional<z.ZodUUID>;
+    tradingPairId: z.ZodOptional<z.ZodUUID>;
+    side: z.ZodOptional<z.ZodString>;
+    orderType: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const ListAppUsersSchema: z.ZodObject<{
+    clientId: z.ZodString;
+    page: z.ZodOptional<z.ZodNever>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    pageToken: z.ZodOptional<z.ZodString>;
+    isActive: z.ZodOptional<z.ZodBoolean>;
+    accountType: z.ZodOptional<z.ZodString>;
+    address: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const ListAppMovementsSchema: z.ZodObject<{
+    clientId: z.ZodString;
+    page: z.ZodOptional<z.ZodNever>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    pageToken: z.ZodOptional<z.ZodString>;
+    userId: z.ZodOptional<z.ZodUUID>;
+    transactionType: z.ZodOptional<z.ZodString>;
+    entryType: z.ZodOptional<z.ZodString>;
+    assetId: z.ZodOptional<z.ZodUUID>;
+}, z.core.$strip>;
+export declare const ListAppBalancesSchema: z.ZodObject<{
+    clientId: z.ZodString;
+    page: z.ZodOptional<z.ZodNever>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    pageToken: z.ZodOptional<z.ZodString>;
+    userId: z.ZodOptional<z.ZodUUID>;
+    assetId: z.ZodOptional<z.ZodUUID>;
+}, z.core.$strip>;

package/dist/validation/applications.js

@@ -0,0 +1,45 @@
+/**
+ * Public application listing validation schemas
+ *
+ * The four reporting listings are cursor paged (0XM-2822). Each schema
+ * REJECTS `page` rather than omitting it: forwarding the params field by
+ * field drops a stray `page` before it reaches the wire, which means a
+ * JavaScript or `any` caller looping on `{ page: n }` would be handed the
+ * FIRST cursor page on every call and would export the same rows forever —
+ * the exact failure the REST 400 exists to surface. Validating here turns
+ * that into an immediate `ValidationError`, which is what the 400 would have
+ * done before the field-by-field forwarding hid it.
+ */
+import { z } from "zod";
+import { UUIDSchema } from "./trading";
+/** A client ID is required; `page` is gone; a page size is bounded; a cursor may be `""` to start. */
+const AppCursorPaginationSchema = z.object({
+    /** The application's public client ID; the listings are selected by it. */
+    clientId: z.string().trim().min(1, "Client ID is required"),
+    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(),
+    pageToken: z.string().optional(),
+});
+export const ListAppOrdersSchema = AppCursorPaginationSchema.extend({
+    status: z.string().trim().min(1, "Status cannot be empty").optional(),
+    userId: UUIDSchema.optional(),
+    tradingPairId: UUIDSchema.optional(),
+    side: z.string().trim().min(1, "Side cannot be empty").optional(),
+    orderType: z.string().trim().min(1, "Order type cannot be empty").optional(),
+});
+export const ListAppUsersSchema = AppCursorPaginationSchema.extend({
+    isActive: z.boolean().optional(),
+    accountType: z.string().trim().min(1, "Account type cannot be empty").optional(),
+    // A partial, case-insensitive match, so not a full address.
+    address: z.string().trim().min(1, "Address filter cannot be empty").optional(),
+});
+export const ListAppMovementsSchema = AppCursorPaginationSchema.extend({
+    userId: UUIDSchema.optional(),
+    transactionType: z.string().trim().min(1, "Transaction type cannot be empty").optional(),
+    entryType: z.string().trim().min(1, "Entry type cannot be empty").optional(),
+    assetId: UUIDSchema.optional(),
+});
+export const ListAppBalancesSchema = AppCursorPaginationSchema.extend({
+    userId: UUIDSchema.optional(),
+    assetId: UUIDSchema.optional(),
+});

package/dist/validation/index.d.ts

@@ -13,6 +13,7 @@
  * - Vault schemas (deposits, withdrawals)
  * - Market schemas (trading pairs, candlesticks)
  */
+export * from "./applications.js";
 export * from "./common.js";
 export * from "./copy-trading.js";
 export * from "./margin-accounts.js";

package/dist/validation/index.js

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

package/dist/validation/margin-accounts.d.ts

@@ -3,8 +3,9 @@
  */
 import { z } from "zod";
 export declare const ListMarginAccountsSchema: z.ZodObject<{
-    page: z.ZodOptional<z.ZodNumber>;
+    page: z.ZodOptional<z.ZodNever>;
     pageSize: z.ZodOptional<z.ZodNumber>;
+    pageToken: z.ZodOptional<z.ZodString>;
     state: z.ZodOptional<z.ZodString>;
     tradingPairId: z.ZodOptional<z.ZodUUID>;
 }, z.core.$strip>;
@@ -70,14 +71,16 @@ export declare const TransferCollateralFromParentMarginAccountSchema: z.ZodObjec
     }, z.core.$strip>;
 }, z.core.$strip>;
 export declare const GetMarginAccountMovementsSchema: z.ZodObject<{
-    page: z.ZodOptional<z.ZodNumber>;
+    page: z.ZodOptional<z.ZodNever>;
     pageSize: z.ZodOptional<z.ZodNumber>;
+    pageToken: z.ZodOptional<z.ZodString>;
     marginAccountId: z.ZodUUID;
     movementType: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const GetParentMarginAccountMovementsSchema: z.ZodOptional<z.ZodObject<{
-    page: z.ZodOptional<z.ZodNumber>;
+    page: z.ZodOptional<z.ZodNever>;
     pageSize: z.ZodOptional<z.ZodNumber>;
+    pageToken: z.ZodOptional<z.ZodString>;
     movementType: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>>;
 export declare const SimulateOrderRiskSchema: z.ZodObject<{
@@ -194,6 +197,10 @@ export declare const CreateMarginSubAccountSchema: z.ZodObject<{
 export declare const CloseMarginSubAccountSchema: z.ZodObject<{
     marginAccountId: z.ZodUUID;
 }, z.core.$strip>;
+export declare const SubAccountCollateralTransferSchema: z.ZodObject<{
+    marginAccountId: z.ZodUUID;
+    amount: z.ZodString;
+}, z.core.$strip>;
 export declare const GetMarginAccountPnlSchema: z.ZodObject<{
     marginAccountId: z.ZodUUID;
 }, z.core.$strip>;

package/dist/validation/margin-accounts.js

@@ -3,11 +3,18 @@
  */
 import { z } from "zod";
 import { MarketSlippageToleranceBpsSchema, OrderSideSchema, OrderTypeSchema, PositionSideSchema, PositiveDecimalStringSchema, UUIDSchema } from "./trading";
-const PaginationSchema = z.object({
-    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(100, "Page size cannot exceed 100").optional(),
+const CursorPaginationSchema = z.object({
+    /**
+     * Rejected, not ignored. A non-strict object would let a JS or `any` caller
+     * keep passing `page`, and the request would then come back as the first
+     * cursor page every time — the same silent duplicate-page failure the REST
+     * 400 guard exists to prevent (0XM-2788).
+     */
+    page: z.never().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(),
 });
-export const ListMarginAccountsSchema = PaginationSchema.extend({
+export const ListMarginAccountsSchema = CursorPaginationSchema.extend({
     state: z.string().trim().min(1, "State cannot be empty").optional(),
     tradingPairId: UUIDSchema.optional(),
 });
@@ -121,11 +128,11 @@ export const TransferCollateralToRiskBucketSchema = z.object({
 export const TransferCollateralFromParentMarginAccountSchema = z.object({
     request: ParentMarginAccountCollateralRequestSchema,
 });
-export const GetMarginAccountMovementsSchema = PaginationSchema.extend({
+export const GetMarginAccountMovementsSchema = CursorPaginationSchema.extend({
     marginAccountId: UUIDSchema,
     movementType: z.string().trim().min(1, "Movement type cannot be empty").optional(),
 });
-export const GetParentMarginAccountMovementsSchema = PaginationSchema.extend({
+export const GetParentMarginAccountMovementsSchema = CursorPaginationSchema.extend({
     movementType: z.string().trim().min(1, "Movement type cannot be empty").optional(),
 }).optional();
 const BaseSimulateOrderRiskRequestSchema = z.object({
@@ -246,6 +253,10 @@ export const CreateMarginSubAccountSchema = z.object({
 export const CloseMarginSubAccountSchema = z.object({
     marginAccountId: UUIDSchema,
 });
+export const SubAccountCollateralTransferSchema = z.object({
+    marginAccountId: UUIDSchema,
+    amount: PositiveDecimalStringSchema,
+});
 export const GetMarginAccountPnlSchema = z.object({
     marginAccountId: UUIDSchema,
 });

package/dist/validation/market.d.ts

@@ -220,3 +220,27 @@ export declare const SearchTradingPairsSchema: z.ZodObject<{
 export declare const GetMarketMetadataSchema: z.ZodObject<{
     tradingPairId: z.ZodUUID;
 }, z.core.$strip>;
+/** Per-pair funding history; the pair id is path-bound and validated separately. */
+export declare const ListFundingHistorySchema: z.ZodObject<{
+    page: z.ZodOptional<z.ZodNever>;
+    startTime: z.ZodOptional<z.ZodString>;
+    endTime: z.ZodOptional<z.ZodString>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    pageToken: z.ZodOptional<z.ZodString>;
+    orderBy: z.ZodOptional<z.ZodEnum<{
+        ASC: "ASC";
+        DESC: "DESC";
+    }>>;
+}, z.core.$strip>;
+/** All-markets funding history. */
+export declare const ListAllFundingHistorySchema: z.ZodObject<{
+    page: z.ZodOptional<z.ZodNever>;
+    startTime: z.ZodOptional<z.ZodString>;
+    endTime: z.ZodOptional<z.ZodString>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    pageToken: z.ZodOptional<z.ZodString>;
+    orderBy: z.ZodOptional<z.ZodEnum<{
+        ASC: "ASC";
+        DESC: "DESC";
+    }>>;
+}, z.core.$strip>;

package/dist/validation/market.js

@@ -224,3 +224,25 @@ export const SearchTradingPairsSchema = z.object({
 export const GetMarketMetadataSchema = z.object({
     tradingPairId: UUIDSchema,
 });
+/**
+ * Funding-history listing validation schemas.
+ *
+ * Cursor paged (0XM-2818). `page` is REJECTED rather than omitted: `withQuery`
+ * builds the query string from `Object.entries(params)`, so an untyped caller's
+ * leftover `page` would otherwise reach the wire and come back as a server
+ * `400` — a round trip to learn what the SDK already knows. Rejecting here
+ * fails the call immediately with a `ValidationError`, and the `deny_unknown_fields`
+ * 400 stays as the server-side backstop.
+ */
+const FundingHistoryCursorSchema = z.object({
+    page: z.never().optional(),
+    startTime: z.string().optional(),
+    endTime: z.string().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(),
+    pageToken: z.string().optional(),
+    orderBy: z.enum(["ASC", "DESC"], { message: 'orderBy must be "ASC" or "DESC"' }).optional(),
+});
+/** Per-pair funding history; the pair id is path-bound and validated separately. */
+export const ListFundingHistorySchema = FundingHistoryCursorSchema;
+/** All-markets funding history. */
+export const ListAllFundingHistorySchema = FundingHistoryCursorSchema;

package/dist/validation/positions.d.ts

@@ -3,8 +3,9 @@
  */
 import { z } from "zod";
 export declare const ListPositionsSchema: z.ZodObject<{
-    page: z.ZodOptional<z.ZodNumber>;
+    page: z.ZodOptional<z.ZodNever>;
     pageSize: z.ZodOptional<z.ZodNumber>;
+    pageToken: z.ZodOptional<z.ZodString>;
     marginAccountId: z.ZodOptional<z.ZodUUID>;
     tradingPairId: z.ZodOptional<z.ZodUUID>;
     status: z.ZodOptional<z.ZodEnum<{
@@ -21,9 +22,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>;
@@ -84,8 +85,9 @@ export declare const AttachPositionTpSlSchema: z.ZodObject<{
     }, z.core.$strip>;
 }, z.core.$strip>;
 export declare const ListPositionHistorySchema: z.ZodObject<{
-    page: z.ZodOptional<z.ZodNumber>;
+    page: z.ZodOptional<z.ZodNever>;
     pageSize: z.ZodOptional<z.ZodNumber>;
+    pageToken: z.ZodOptional<z.ZodString>;
     positionId: z.ZodOptional<z.ZodUUID>;
     marginAccountId: z.ZodOptional<z.ZodUUID>;
     tradingPairId: z.ZodOptional<z.ZodUUID>;

package/dist/validation/positions.js

@@ -3,9 +3,16 @@
  */
 import { z } from "zod";
 import { ConditionalTimeInForceSchema, ISO8601DateSchema, OrderTypeSchema, PositiveDecimalStringSchema, SlippageToleranceBpsSchema, TrailingStopLegSchema, UUIDSchema, } from "./trading";
-const PaginationSchema = z.object({
-    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(100, "Page size cannot exceed 100").optional(),
+const CursorPaginationSchema = z.object({
+    /**
+     * Rejected, not ignored. A non-strict object would let a JS or `any` caller
+     * keep passing `page`, and the request would then come back as the first
+     * cursor page every time — the same silent duplicate-page failure the REST
+     * 400 guard exists to prevent (0XM-2788).
+     */
+    page: z.never().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(),
 });
 // Filter values accepted by the list-positions endpoint. Narrower than the
 // returned PositionStatus: the backend folds EXPIRED positions under CLOSED, so
@@ -19,7 +26,7 @@ const ClosePositionTypeSchema = z.enum(["MARKET", "LIMIT", "IOC"], {
 const PositionIdSchema = z.object({
     positionId: UUIDSchema,
 });
-export const ListPositionsSchema = PaginationSchema.extend({
+export const ListPositionsSchema = CursorPaginationSchema.extend({
     marginAccountId: UUIDSchema.optional(),
     tradingPairId: UUIDSchema.optional(),
     status: PositionStatusSchema.optional(),
@@ -100,7 +107,7 @@ export const AttachPositionTpSlSchema = PositionIdSchema.extend({
         path: ["oco"],
     }),
 });
-export const ListPositionHistorySchema = PaginationSchema.extend({
+export const ListPositionHistorySchema = CursorPaginationSchema.extend({
     positionId: UUIDSchema.optional(),
     marginAccountId: UUIDSchema.optional(),
     tradingPairId: UUIDSchema.optional(),

package/dist/validation/profile.d.ts

@@ -48,8 +48,13 @@ export declare const SetSelfTradePreventionDefaultSchema: z.ZodObject<{
  * All fields are optional — an empty object or undefined is valid.
  */
 export declare const GetUserMovementsSchema: z.ZodObject<{
-    page: z.ZodOptional<z.ZodNumber>;
+    page: z.ZodOptional<z.ZodNever>;
     pageSize: z.ZodOptional<z.ZodNumber>;
+    pageToken: z.ZodOptional<z.ZodString>;
+    orderBy: z.ZodOptional<z.ZodEnum<{
+        ASC: "ASC";
+        DESC: "DESC";
+    }>>;
     entryType: z.ZodOptional<z.ZodEnum<{
         CREDIT: "CREDIT";
         DEBIT: "DEBIT";
@@ -81,9 +86,21 @@ export declare const GetUserTradesSchema: z.ZodObject<{
     tradingPairId: z.ZodOptional<z.ZodUUID>;
     pageToken: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
+/**
+ * Get User Balances validation schema
+ *
+ * Validates parameters for the cursor-paged balances listing. All fields are
+ * optional — an empty object or undefined is valid.
+ */
+export declare const GetUserBalancesSchema: z.ZodObject<{
+    page: z.ZodOptional<z.ZodNever>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    pageToken: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
 export declare const ListFundingPaymentsSchema: z.ZodObject<{
-    page: z.ZodOptional<z.ZodNumber>;
+    page: z.ZodOptional<z.ZodNever>;
     pageSize: z.ZodOptional<z.ZodNumber>;
+    pageToken: z.ZodOptional<z.ZodString>;
     tradingPairId: z.ZodOptional<z.ZodUUID>;
     positionId: z.ZodOptional<z.ZodUUID>;
     marginAccountId: z.ZodOptional<z.ZodUUID>;

package/dist/validation/profile.js

@@ -33,8 +33,16 @@ export const SetSelfTradePreventionDefaultSchema = z.object({
  * All fields are optional — an empty object or undefined is valid.
  */
 export const GetUserMovementsSchema = z.object({
-    page: z.number().int("Page must be an integer").min(1, "Page must be at least 1").optional(),
-    pageSize: z.number().int("Page size must be an integer").min(1, "Page size must be at least 1").max(100, "Page size cannot exceed 100").optional(),
+    /**
+     * Rejected, not ignored. A non-strict object would let a JS or `any` caller
+     * keep passing `page`, and the request would come back as the first cursor
+     * page every time — the same silent duplicate-page failure the REST 400
+     * guard exists to prevent (0XM-2788).
+     */
+    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(),
+    pageToken: z.string().optional(),
+    orderBy: z.enum(["ASC", "DESC"]).optional(),
     entryType: LedgerEntryTypeSchema.optional(),
     transactionType: TransactionTypeSchema.optional(),
     assetId: UUIDSchema.optional(),
@@ -57,9 +65,33 @@ export const GetUserTradesSchema = z.object({
     tradingPairId: UUIDSchema.optional(),
     pageToken: z.string().optional(),
 });
+/**
+ * Get User Balances validation schema
+ *
+ * Validates parameters for the cursor-paged balances listing. All fields are
+ * optional — an empty object or undefined is valid.
+ */
+export const GetUserBalancesSchema = z.object({
+    /**
+     * Rejected, not ignored. Without a schema at all a JS or `any` caller's
+     * `page` was silently dropped while building the query string, so the call
+     * resolved with the FIRST cursor page on every request — the quiet
+     * duplicate-page failure the REST 400 guard exists to prevent (0XM-2821).
+     */
+    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(),
+    pageToken: z.string().optional(),
+});
 export const ListFundingPaymentsSchema = z.object({
-    page: z.number().int("Page must be an integer").min(1, "Page must be at least 1").optional(),
-    pageSize: z.number().int("Page size must be an integer").min(1, "Page size must be at least 1").max(100, "Page size cannot exceed 100").optional(),
+    /**
+     * Rejected, not ignored. A non-strict object would let a JS or `any` caller
+     * keep passing `page`, and the request would come back as the first cursor
+     * page every time — the same silent duplicate-page failure the REST 400
+     * guard exists to prevent (0XM-2788).
+     */
+    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(),
+    pageToken: z.string().optional(),
     tradingPairId: UUIDSchema.optional(),
     positionId: UUIDSchema.optional(),
     marginAccountId: UUIDSchema.optional(),

package/dist/validation/trading.d.ts

@@ -375,11 +375,11 @@ export declare const ConditionalOrderTriggerSourceSchema: z.ZodEnum<{
 export declare const ConditionalOrderStateSchema: z.ZodEnum<{
     CANCELLED: "CANCELLED";
     EXPIRED: "EXPIRED";
-    FAILED: "FAILED";
     PENDING_PARENT: "PENDING_PARENT";
     ACTIVE: "ACTIVE";
     TRIGGERING: "TRIGGERING";
     TRIGGERED: "TRIGGERED";
+    FAILED: "FAILED";
 }>;
 export declare const ClosePositionSideSchema: z.ZodEnum<{
     LONG: "LONG";
@@ -395,11 +395,11 @@ export declare const ListConditionalOrdersSchema: z.ZodObject<{
     state: z.ZodOptional<z.ZodEnum<{
         CANCELLED: "CANCELLED";
         EXPIRED: "EXPIRED";
-        FAILED: "FAILED";
         PENDING_PARENT: "PENDING_PARENT";
         ACTIVE: "ACTIVE";
         TRIGGERING: "TRIGGERING";
         TRIGGERED: "TRIGGERED";
+        FAILED: "FAILED";
     }>>;
     pageSize: z.ZodOptional<z.ZodNumber>;
     pageToken: z.ZodOptional<z.ZodString>;

package/dist/websocket/base.d.ts

@@ -7,8 +7,40 @@
  * WebSocket connection status
  */
 export type WebSocketStatus = "connected" | "connecting" | "disconnected" | "reconnecting";
-/** Handler invoked whenever the WebSocket connection status changes. */
-export type StatusHandler = (status: WebSocketStatus) => void;
+/**
+ * Connection-attempt context delivered with every status change.
+ *
+ * `"reconnecting"` with `hasConnected: false` means the client has never
+ * reached the server and is still trying (the first connect failed);
+ * `hasConnected: true` means a working connection was lost.
+ */
+export interface WebSocketStatusInfo {
+    /**
+     * The retry this status refers to. `0` for `"connecting"` and
+     * `"connected"`; `1`, `2`, … for `"reconnecting"` (the retry just
+     * scheduled); for `"disconnected"`, the number of retries scheduled in the
+     * outage before it, counting one still in backoff when `disconnect()` is
+     * called (`0` after a clean close of a working connection).
+     */
+    attempt: number;
+    /**
+     * Whether this client has reached the server at least once since it was
+     * created or since the last `disconnect()`.
+     */
+    hasConnected: boolean;
+    /**
+     * Set only on `"reconnecting"`: the delay, in milliseconds, before the
+     * scheduled retry opens its connection.
+     */
+    nextRetryDelayMs?: number;
+}
+/**
+ * Handler invoked whenever the WebSocket connection status changes.
+ *
+ * Inside the handler, `getStatus()` returns the status being reported. A
+ * handler that takes only `status` remains valid.
+ */
+export type StatusHandler = (status: WebSocketStatus, info: WebSocketStatusInfo) => void;
 /**
  * Why the connection was re-established. Delivered by
  * {@link MonacoWebSocketConfig.onResync} after the socket reopens and sends its
@@ -129,9 +161,11 @@ export interface MonacoWebSocketConfig {
     /** Enable auto-reconnect on disconnect (default: true) */
     autoReconnect?: boolean;
     /**
-     * Maximum reconnection attempts (default: unlimited). Retry delay is
-     * full-jitter exponential backoff capped at 30s, so unlimited retries are
-     * capped-rate, not a tight loop.
+     * Maximum reconnection attempts per outage (default: unlimited). Retry
+     * delay is full-jitter exponential backoff capped at 30s, so unlimited
+     * retries are capped-rate, not a tight loop. Once the attempts run out the
+     * client reports `"disconnected"`; a later `connect()` starts a fresh
+     * budget.
      */
     maxReconnectAttempts?: number;
     /** Base delay for the exponential backoff in milliseconds (default: 1000) */
@@ -141,7 +175,23 @@ export interface MonacoWebSocketConfig {
      * retried, in milliseconds (default: 10000)
      */
     connectionTimeoutMs?: number;
-    /** Callback for connection status changes */
+    /**
+     * Called on every connection status change, with the attempt context in
+     * {@link WebSocketStatusInfo}:
+     *
+     * - `"connecting"` — a connection is opening outside a retry cycle: the
+     *   first connect, a `connect()` after a terminal `"disconnected"`, or a
+     *   fresh session's reconnect after terminal authentication loss.
+     * - `"connected"` — the connection opened.
+     * - `"reconnecting"` — a retry is scheduled, once per retry. It holds until
+     *   a retry connects or the retries run out; retries do not report
+     *   `"connecting"`.
+     * - `"disconnected"` — terminal: a clean close, retries exhausted, terminal
+     *   authentication loss, or `disconnect()`.
+     *
+     * An error thrown by this callback, or a rejection of the promise an async
+     * callback returns, is logged and does not affect the connection.
+     */
     onStatusChange?: StatusHandler;
     /**
      * Called after every automatic reconnect sends authentication/subscription