@0xmonaco/types 1.0.73 → 1.0.74-develop.367860f

package/dist/trading/index.d.ts

@@ -267,6 +267,6 @@ export interface TradingAPI extends BaseAPI {
      */
     listTwapOrders(params?: ListTwapOrdersParams): Promise<ListTwapOrdersResponse>;
 }
-export type { ConditionalOrderConditionType, ConditionalOrderState, ConditionalOrderTriggerSource, ListedOrderType, Order, OrderRole, OrderSide, OrderStatus, OrderStatusFilter, OrderTerminalReason, OrderType, PositionSide, SelfTradePreventionMode, TimeInForce, TradingMode, TwapExecutionStyle, TwapOrderState, } from "./orders";
+export type { ConditionalOrderConditionType, ConditionalOrderState, ConditionalOrderTriggerSource, Order, OrderRole, OrderSide, OrderStatus, OrderStatusFilter, OrderTerminalReason, OrderType, PositionSide, SelfTradePreventionMode, TimeInForce, TradingMode, TwapExecutionStyle, TwapOrderState, } from "./orders";
 export { ORDER_STATUS_VALUES } from "./orders";
 export type { BatchCancelError, BatchCancelOrdersResponse, BatchCancelResult, BatchCreateOrderParams, BatchCreateOrdersResponse, BatchCreateResult, BatchError, BatchReplaceOrderParams, BatchReplaceOrdersResponse, BatchReplaceResult, CancelConditionalOrderResponse, CancelOrderResponse, CancelTwapOrderResponse, ConditionalOrder, CreateOrderResponse, CreateTwapOrderOptions, CreateTwapOrderResponse, GetOrderResponse, GetPaginatedOrdersParams, GetPaginatedOrdersResponse, GetTwapOrderTcaResponse, ListConditionalOrdersParams, ListConditionalOrdersResponse, ListTwapOrdersParams, ListTwapOrdersResponse, MatchResult, ParentTpSlLegParams, ParentTrailingStopLegParams, ReplaceOrderResponse, TriggeredOrderSummary, TwapOrder, UpdatedFields, } from "./responses";

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" | "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,8 +13,10 @@
  * - Vault schemas (deposits, withdrawals)
  * - Market schemas (trading pairs, candlesticks)
  */
+export * from "./applications.js";
 export * from "./common.js";
 export * from "./copy-trading.js";
+export * from "./managed-markets.js";
 export * from "./margin-accounts.js";
 export * from "./market.js";
 export * from "./positions.js";

package/dist/validation/index.js

@@ -14,8 +14,10 @@
  * - Market schemas (trading pairs, candlesticks)
  */
 // Export validation utilities
+export * from "./applications.js";
 export * from "./common.js";
 export * from "./copy-trading.js";
+export * from "./managed-markets.js";
 export * from "./margin-accounts.js";
 export * from "./market.js";
 export * from "./positions.js";

package/dist/validation/managed-markets.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Managed Markets API Validation Schemas
+ */
+import { z } from "zod";
+/**
+ * Managed market assignments listing validation schema.
+ *
+ * Cursor paged (0XM-2821). `page` is REJECTED rather than omitted: the client
+ * builds the query string field by field, so a stray `page` never reaches the
+ * REST guard, and a caller looping `{ page: 1 }`, `{ page: 2 }` would send
+ * identical cursorless requests and reread the first page forever.
+ */
+export declare const ListManagedMarketAssignmentsSchema: z.ZodObject<{
+    page: z.ZodOptional<z.ZodNever>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    pageToken: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;

package/dist/validation/managed-markets.js

@@ -0,0 +1,17 @@
+/**
+ * Managed Markets API Validation Schemas
+ */
+import { z } from "zod";
+/**
+ * Managed market assignments listing validation schema.
+ *
+ * Cursor paged (0XM-2821). `page` is REJECTED rather than omitted: the client
+ * builds the query string field by field, so a stray `page` never reaches the
+ * REST guard, and a caller looping `{ page: 1 }`, `{ page: 2 }` would send
+ * identical cursorless requests and reread the first page forever.
+ */
+export const ListManagedMarketAssignmentsSchema = z.object({
+    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(),
+});

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>;
@@ -50,12 +51,14 @@ export declare const TransferCollateralToRiskBucketSchema: z.ZodObject<{
         tradingPairId: z.ZodUUID;
         strategyKey: z.ZodOptional<z.ZodString>;
         marginMode: z.ZodOptional<z.ZodLiteral<"ISOLATED">>;
+        marginAccountId: z.ZodOptional<z.ZodUUID>;
         selectedTradingPairIds: z.ZodOptional<z.ZodNever>;
         applyToPositionMargin: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strict>, z.ZodObject<{
         asset: z.ZodString;
         amount: z.ZodString;
         marginMode: z.ZodLiteral<"CROSS">;
+        marginAccountId: z.ZodOptional<z.ZodUUID>;
         selectedTradingPairIds: z.ZodOptional<z.ZodNever>;
         strategyKey: z.ZodOptional<z.ZodNever>;
         tradingPairId: z.ZodOptional<z.ZodNever>;
@@ -68,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<{
@@ -154,6 +159,7 @@ export declare const SimulateRiskBucketOrderRiskSchema: z.ZodObject<{
         tradingPairId: z.ZodUUID;
         strategyKey: z.ZodOptional<z.ZodString>;
         marginMode: z.ZodOptional<z.ZodLiteral<"ISOLATED">>;
+        marginAccountId: z.ZodOptional<z.ZodUUID>;
         selectedTradingPairIds: z.ZodOptional<z.ZodNever>;
         applyToPositionMargin: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strict>, z.ZodObject<{
@@ -177,7 +183,42 @@ export declare const SimulateRiskBucketOrderRiskSchema: z.ZodObject<{
         reduceOnly: z.ZodOptional<z.ZodBoolean>;
         slippageToleranceBps: z.ZodOptional<z.ZodNumber>;
         marginMode: z.ZodLiteral<"CROSS">;
+        marginAccountId: z.ZodOptional<z.ZodUUID>;
         selectedTradingPairIds: z.ZodOptional<z.ZodNever>;
         strategyKey: z.ZodOptional<z.ZodNever>;
     }, z.core.$strict>]>>;
 }, z.core.$strip>;
+export declare const CreateMarginSubAccountSchema: z.ZodObject<{
+    request: z.ZodObject<{
+        subaccountKey: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strip>;
+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>;
+export declare const TransferMarginCollateralSchema: z.ZodObject<{
+    request: z.ZodObject<{
+        asset: z.ZodString;
+        amount: z.ZodString;
+        from: z.ZodUnion<readonly [z.ZodObject<{
+            wallet: z.ZodLiteral<true>;
+        }, z.core.$strict>, z.ZodObject<{
+            marginAccountId: z.ZodUUID;
+            riskBucketId: z.ZodOptional<z.ZodUUID>;
+        }, z.core.$strict>]>;
+        to: z.ZodUnion<readonly [z.ZodObject<{
+            wallet: z.ZodLiteral<true>;
+        }, z.core.$strict>, z.ZodObject<{
+            marginAccountId: z.ZodUUID;
+            riskBucketId: z.ZodOptional<z.ZodUUID>;
+        }, z.core.$strict>]>;
+    }, z.core.$strict>;
+}, 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(),
 });
@@ -49,6 +56,9 @@ const RiskBucketRequestSchema = z.object({
 });
 const IsolatedRiskBucketRequestSchema = RiskBucketRequestSchema.extend({
     marginMode: z.literal("ISOLATED").optional(),
+    // A sub-account funds and previews its own risk buckets; omitted means the
+    // default margin account.
+    marginAccountId: UUIDSchema.optional(),
     selectedTradingPairIds: z.never().optional(),
     // Omitted defaults server-side to true (the Adjust Margin gesture); false
     // is the plain allocation programmatic funding loops need. The CROSS form
@@ -64,6 +74,7 @@ const IsolatedRiskBucketRequestSchema = RiskBucketRequestSchema.extend({
 // the pair being previewed, not a scope declaration.
 const CrossRiskBucketSimulateRequestSchema = z.object({
     marginMode: z.literal("CROSS"),
+    marginAccountId: UUIDSchema.optional(),
     selectedTradingPairIds: z.never().optional(),
     strategyKey: z.never().optional(),
 });
@@ -74,6 +85,7 @@ const CrossRiskBucketSimulateRequestSchema = z.object({
 // it does nothing rather than believing it took effect.
 const CrossRiskBucketRequestSchema = z.object({
     marginMode: z.literal("CROSS"),
+    marginAccountId: UUIDSchema.optional(),
     selectedTradingPairIds: z.never().optional(),
     strategyKey: z.never().optional(),
     tradingPairId: z.never().optional(),
@@ -116,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({
@@ -223,3 +235,42 @@ export const SimulateRiskBucketOrderRiskSchema = z
     message: "price is required for LIMIT risk simulations",
     path: ["request", "price"],
 });
+export const CreateMarginSubAccountSchema = z.object({
+    request: z
+        .object({
+        subaccountKey: z
+            .string()
+            .trim()
+            .min(1, "subaccountKey is required")
+            .max(64, "subaccountKey must be at most 64 characters")
+            .regex(/^[A-Za-z0-9_.:-]+$/, "subaccountKey may contain only letters, digits, '_', '-', '.' and ':'")
+            .refine((key) => !key.toLowerCase().startsWith("copy:"), "sub-account keys starting with copy: are reserved")
+            .refine((key) => key !== "default", "default names the default margin account"),
+        label: z.string().optional(),
+    })
+        .strict(),
+});
+export const CloseMarginSubAccountSchema = z.object({
+    marginAccountId: UUIDSchema,
+});
+export const SubAccountCollateralTransferSchema = z.object({
+    marginAccountId: UUIDSchema,
+    amount: PositiveDecimalStringSchema,
+});
+export const GetMarginAccountPnlSchema = z.object({
+    marginAccountId: UUIDSchema,
+});
+const CollateralTransferEndpointSchema = z.union([
+    z.object({ wallet: z.literal(true) }).strict(),
+    z.object({ marginAccountId: UUIDSchema, riskBucketId: UUIDSchema.optional() }).strict(),
+]);
+export const TransferMarginCollateralSchema = z.object({
+    request: z
+        .object({
+        asset: z.string().trim().min(1, "Asset is required"),
+        amount: PositiveDecimalStringSchema,
+        from: CollateralTransferEndpointSchema,
+        to: CollateralTransferEndpointSchema,
+    })
+        .strict(),
+});

package/dist/validation/market.d.ts

@@ -220,3 +220,48 @@ 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>;
+/**
+ * Public trades-feed listing validation schema.
+ *
+ * Cursor paged (0XM-2821). `page` is REJECTED rather than omitted, but NOT for
+ * the same reason as {@link ListFundingHistorySchema}. That one is built on a
+ * query builder that serializes whatever keys the params object carries, so a
+ * leftover `page` reaches the wire and comes back as the server's `400`.
+ * `getTrades` instead sets `pageSize` and `pageToken` explicitly, so a stray
+ * `page` never leaves the client at all — which makes rejecting it more
+ * important here, not less. Stripped silently, it would leave the caller
+ * requesting page 2, 3, 4 and receiving the FIRST cursor page every time, with
+ * no error from either side to reveal the loop. `z.never()` turns that silent
+ * non-advancing walk into an immediate `ValidationError`.
+ *
+ * The ceiling is the cursor-mode 1000; the historical default of 25 stays.
+ */
+export declare const GetTradesSchema: z.ZodObject<{
+    page: z.ZodOptional<z.ZodNever>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    pageToken: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;

package/dist/validation/market.js

@@ -224,3 +224,46 @@ 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;
+/**
+ * Public trades-feed listing validation schema.
+ *
+ * Cursor paged (0XM-2821). `page` is REJECTED rather than omitted, but NOT for
+ * the same reason as {@link ListFundingHistorySchema}. That one is built on a
+ * query builder that serializes whatever keys the params object carries, so a
+ * leftover `page` reaches the wire and comes back as the server's `400`.
+ * `getTrades` instead sets `pageSize` and `pageToken` explicitly, so a stray
+ * `page` never leaves the client at all — which makes rejecting it more
+ * important here, not less. Stripped silently, it would leave the caller
+ * requesting page 2, 3, 4 and receiving the FIRST cursor page every time, with
+ * no error from either side to reveal the loop. `z.never()` turns that silent
+ * non-advancing walk into an immediate `ValidationError`.
+ *
+ * The ceiling is the cursor-mode 1000; the historical default of 25 stays.
+ */
+export const GetTradesSchema = z.object({
+    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(),
+});

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(),