@0xmonaco/types 1.0.67 → 1.0.70

package/dist/copy-trading/responses.js

@@ -0,0 +1,268 @@
+/**
+ * Copy trading response types (0XM-2851).
+ *
+ * Zod schemas for every copy trading REST/gRPC response, with the inferred
+ * TypeScript types. The REST API returns camelCase JSON; an optional field the
+ * server has no value for arrives as `null`, so optional fields are typed
+ * `T | null | undefined` (`.nullish()`).
+ *
+ * Leaders are only ever identified by their public wallet address and custom
+ * TraderCode handle, never by an internal id.
+ *
+ * Label fields (statuses, modes, reasons) are typed `Union | (string & {})`:
+ * the unions name the values the server sends today, and the schemas accept
+ * any string so a value added server-side later does not fail parsing.
+ */
+import { z } from "zod";
+/** A string schema typed as a known-value union that still admits unknown values. */
+function openUnion() {
+    return z.string();
+}
+/** A lead trader as the public sees them: wallet and handle, never an internal id. */
+export const LeadTraderRefSchema = z.object({
+    /** The leader's wallet address (lowercase hex). */
+    walletAddress: z.string(),
+    /** The leader's custom TraderCode handle, when claimed. */
+    handle: z.string().nullish(),
+    /** The handle when claimed, else the wallet address. */
+    display: z.string(),
+});
+/** A lead trader's public profile. */
+export const LeadTraderProfileSchema = z.object({
+    leader: LeadTraderRefSchema,
+    /** `ACTIVE` (accepting follows), `PAUSED` (existing follows keep mirroring, no new follows) or `SUSPENDED` (own profile only). */
+    status: openUnion(),
+    /** The leader's share of followers' realized profit, in basis points. */
+    shareBps: z.number(),
+    /** Free-text profile description; empty when none. */
+    bio: z.string(),
+    /** Minimum follow allocation in quote units, when above the platform floor. */
+    minAllocation: z.string().nullish(),
+    /** Registration time (RFC 3339). */
+    registeredAt: z.string(),
+});
+/** Live follows of a leader. */
+export const LeadTraderFollowSummarySchema = z.object({
+    /** Live follows (`ACTIVE` or `CLOSE_ONLY`). */
+    followerCount: z.number(),
+    /** Collateral allocated by live follows, in quote units (AUM as allocated, not marked). */
+    allocated: z.string(),
+    /**
+     * Equity of live follows' copy accounts at the engine's marks, in quote
+     * units (AUM marked: collateral plus unrealized PnL of copy positions).
+     * Absent when it could not be read. Not trading PnL.
+     */
+    aumEquity: z.string().nullish(),
+});
+/** A leader's trading stats over one window. */
+export const LeadTraderStatsSchema = z.object({
+    /** `7d`, `30d`, `90d` or `all`. */
+    window: openUnion(),
+    /** Trading PnL over the window in quote units: realized plus unrealized, net of fees and funding. */
+    pnl: z.string(),
+    /** PnL as a percentage of the highest base balance over the window; absent when that base is not positive. */
+    roiPct: z.string().nullish(),
+    /** Largest peak-to-trough fall of cumulative PnL over the window, as a percentage of the highest base balance. */
+    maxDrawdownPct: z.string().nullish(),
+    /** Winning closes as a percentage of winning plus losing closes; absent when there were none. */
+    winRatePct: z.string().nullish(),
+    /** Closes over the window, break-even included. */
+    closedTrades: z.number(),
+});
+/** One lead trader: profile, follow summary and stats for every window (7d, 30d, 90d, all). */
+export const GetLeadTraderResponseSchema = z.object({
+    profile: LeadTraderProfileSchema,
+    followSummary: LeadTraderFollowSummarySchema,
+    stats: z.array(LeadTraderStatsSchema),
+});
+/** One leaderboard row: stats for the requested window only. */
+export const LeadTraderListingSchema = z.object({
+    profile: LeadTraderProfileSchema,
+    followSummary: LeadTraderFollowSummarySchema,
+    stats: LeadTraderStatsSchema,
+});
+/** A page of the public leaderboard. */
+export const ListLeadTradersResponseSchema = z.object({
+    leaders: z.array(LeadTraderListingSchema),
+    /** Cursor for the next page; empty at the end. Pinned to the sort and window that produced it. */
+    nextPageToken: z.string(),
+    /** Time of the leaderboard snapshot these rows come from (RFC 3339). */
+    asOf: z.string(),
+});
+/** Result of registering as, or editing, a lead trader. */
+export const UpsertLeadTraderResponseSchema = z.object({
+    /** True when this call registered you, false when it edited your profile. */
+    created: z.boolean(),
+    /** Your status after the call. */
+    status: openUnion(),
+    /** Your profit share after the call, in basis points. */
+    shareBps: z.number(),
+});
+/** One of your followers, as a leader sees them. */
+export const FollowerSchema = z.object({
+    /** The follower's wallet address (lowercase hex). */
+    walletAddress: z.string(),
+    /** The follower's custom TraderCode handle when claimed, else the wallet address. */
+    display: z.string(),
+    /** `ACTIVE` or `CLOSE_ONLY`. */
+    status: openUnion(),
+    /** Collateral allocated to the follow, in quote units. */
+    allocation: z.string(),
+    /** When the follow started (RFC 3339). */
+    startedAt: z.string(),
+});
+/** A page of your followers. */
+export const ListMyFollowersResponseSchema = z.object({
+    followers: z.array(FollowerSchema),
+    /** Cursor for the next page; empty at the end. */
+    nextPageToken: z.string(),
+});
+/** One reducing execution of a leader's position. */
+export const ClosedTradeSchema = z.object({
+    tradingPairId: z.string(),
+    /** `LONG` or `SHORT`; empty on legacy rows. */
+    positionSide: z.string(),
+    /** `DECREASE`, `CLOSE`, `LIQUIDATE` or `ADL`. */
+    action: openUnion(),
+    /** Closed size in base units. */
+    size: z.string().nullish(),
+    /** Execution price. */
+    exitPrice: z.string().nullish(),
+    /** Average entry price of the position at the close. */
+    entryPrice: z.string().nullish(),
+    /** Gross realized PnL of the execution, in quote units. */
+    realizedPnl: z.string().nullish(),
+    /** Realized PnL net of the execution's fees and funding, in quote units. */
+    netRealizedPnl: z.string().nullish(),
+    /** Net realized PnL as a percentage of the initial margin released by the execution. */
+    realizedRoe: z.string().nullish(),
+    /** Execution time (RFC 3339). */
+    closedAt: z.string(),
+});
+/** A page of a leader's closed trades. */
+export const ListLeadTraderClosedTradesResponseSchema = z.object({
+    closedTrades: z.array(ClosedTradeSchema),
+    /** Cursor for the next page; empty at the end. */
+    nextPageToken: z.string(),
+});
+/** One open position of a leader you follow. */
+export const LeadTraderOpenPositionSchema = z.object({
+    tradingPairId: z.string(),
+    /** `LONG` or `SHORT`. */
+    side: z.string(),
+    /** Position size in base units. */
+    size: z.string(),
+    /** Average entry price. */
+    entryPrice: z.string(),
+    /** Current mark price. */
+    markPrice: z.string().nullish(),
+    /** Unrealized PnL at the mark, in quote units. */
+    unrealizedPnl: z.string().nullish(),
+    /** Position leverage. */
+    leverage: z.string().nullish(),
+    /** `CROSS` or `ISOLATED`. */
+    marginMode: z.string(),
+});
+/** A followed leader's open positions (current followers only). */
+export const ListLeadTraderOpenPositionsResponseSchema = z.object({
+    positions: z.array(LeadTraderOpenPositionSchema),
+});
+/** One of your follows. */
+export const FollowSchema = z.object({
+    /** The follow's id. */
+    followId: z.string(),
+    leader: LeadTraderRefSchema,
+    /** `ACTIVE`, `CLOSE_ONLY` (only reductions mirror) or `STOPPED`. */
+    status: openUnion(),
+    /** `FOLLOW`, `CROSS` or `ISOLATED`. */
+    marginModePolicy: openUnion(),
+    /** `PROPORTIONAL` or `FIXED_MARGIN`. */
+    sizingMode: openUnion(),
+    /** Margin per leader order for `FIXED_MARGIN`, in quote units. */
+    sizingParam: z.string().nullish(),
+    /** `FOLLOW` or `FIXED`. */
+    leverageMode: openUnion(),
+    /** Leverage for `FIXED`. */
+    fixedLeverage: z.string().nullish(),
+    /** Collateral allocated to the follow, in quote units. */
+    allocation: z.string(),
+    /** Copy stop-loss as a fraction of the allocation. */
+    slPct: z.string().nullish(),
+    /** Whether the follow copied the leader's open positions at creation. */
+    copyExisting: z.boolean(),
+    /** Markets mirrored; empty means every market the leader trades. */
+    tradingPairIds: z.array(z.string()),
+    /** Consecutive mirrors skipped for insufficient margin. */
+    consecutiveSkips: z.number(),
+    /** The copy account's cross risk bucket in your margin account. */
+    copyRiskBucketId: z.string(),
+    /** When the follow started (RFC 3339). */
+    startedAt: z.string(),
+    /** When the follow stopped (RFC 3339). */
+    stoppedAt: z.string().nullish(),
+    /** `FOLLOWER`, `STOP_LOSS`, `SKIP_LIMIT`, `ADMIN` or `LEADER_SUSPENDED`. */
+    stopReason: openUnion().nullish(),
+});
+/** A page of your follows. */
+export const ListMyFollowsResponseSchema = z.object({
+    follows: z.array(FollowSchema),
+    /** Cursor for the next page; empty at the end. */
+    nextPageToken: z.string(),
+});
+/** A leader fill one of your follows did not mirror. */
+export const CopySkipSchema = z.object({
+    /** Trading pair of the leader fill. */
+    tradingPairId: z.string(),
+    /** Why the mirror was skipped, e.g. `INSUFFICIENT_MARGIN`. */
+    reason: openUnion(),
+    /** The copy quantity that could not be placed, in base units. */
+    requestedQuantity: z.string(),
+    /** When the mirror was skipped (RFC 3339). */
+    skippedAt: z.string(),
+});
+/** One of your follows with its most recent skips (up to 100). */
+export const GetFollowResponseSchema = z.object({
+    follow: FollowSchema,
+    recentSkips: z.array(CopySkipSchema),
+    /**
+     * The copy account's equity at the engine's marks, in quote units: its
+     * collateral plus the unrealized PnL of its positions. Absent when the
+     * engine could not be read. A balance, not trading PnL.
+     */
+    copyAccountEquity: z.string().nullish(),
+});
+/** The open positions of the leader one of your follows copies. */
+export const ListFollowLeaderPositionsResponseSchema = z.object({
+    positions: z.array(LeadTraderOpenPositionSchema),
+});
+/** Result of following a leader or editing a follow. */
+export const UpsertFollowResponseSchema = z.object({
+    /** The follow's id. */
+    followId: z.string(),
+    /** The copy account: the cross risk bucket in your margin account that holds this follow's collateral and positions. */
+    copyRiskBucketId: z.string(),
+    /** True when this call created the follow, false when it edited one. */
+    created: z.boolean(),
+});
+/**
+ * What following with `copyExisting` would open, as totals only. The caller
+ * is never a follower of the leader, so the preview names no pair, side,
+ * size, mark or skip reason. Totals are rounded up to cents.
+ */
+export const PreviewFollowResponseSchema = z.object({
+    /** Estimated collateral the copied positions would reserve at placement, in quote units. */
+    estimatedMargin: z.string(),
+    /** Estimated taker fees of the copies, in quote units. */
+    estimatedFee: z.string(),
+    /** The leader's positions (in the copied markets) that would be copied. */
+    copiedPositions: z.number(),
+    /** The leader's positions (in the copied markets) that would not be copied. */
+    skippedPositions: z.number(),
+    /** More leader positions matched than one preview sizes (64); the totals and counts cover the first ones. */
+    truncated: z.boolean(),
+});
+/** Result of stopping a follow. */
+export const StopFollowResponseSchema = z.object({
+    /** The stopped follow's id. */
+    followId: z.string(),
+});

package/dist/delegated-agents/index.d.ts

@@ -5,13 +5,19 @@ export interface UpsertDelegatedAgentRequest {
     agentAddress: string;
     name?: string;
     expiresAt?: string;
+    /** Required. An empty list permits no actions. */
     allowedActions: DelegatedAgentAction[];
+    /** Required. A matching market OR account permits an order; both scopes empty deny all orders. */
     allowedTradingPairIds: string[];
+    /** Additional account scope. Omit or send [] for market-only scope, not access to every account. */
     allowedMarginAccountIds?: string[];
+    /** Omit or send [] for unrestricted order types. */
     allowedOrderTypes?: Array<"LIMIT" | "MARKET">;
+    /** Omit or send [] for unrestricted time in force. */
     allowedTimeInForce?: Array<"GTC" | "IOC" | "FOK">;
     maxLeverage?: string;
     maxOrderNotional?: string;
+    /** @deprecated Unsupported: setting this field causes the server to reject the request. */
     maxOpenOrders?: number;
 }
 export interface DelegatedAgent {
@@ -29,6 +35,7 @@ export interface DelegatedAgent {
     allowedTimeInForce?: string[];
     maxLeverage?: string;
     maxOrderNotional?: string;
+    /** @deprecated Legacy data only; no concurrent open-order cap is enforced. */
     maxOpenOrders?: number;
 }
 export interface ListDelegatedAgentsResponse {

package/dist/faucet/index.d.ts

@@ -117,8 +117,9 @@ export interface FaucetAPI extends BaseAPI {
      * Fetches the authenticated wallet's faucet quota and recent requests.
      *
      * Read-only: remaining requests in the rolling 24h window, when the next
-     * request becomes available, and the 5 most recent requests. Wallet-scoped
-     * across apps, matching mint enforcement.
+     * request becomes available, and the 5 most recent requests. Scoped to the
+     * wallet on this app (each app has its own quota), matching mint
+     * enforcement.
      *
      * @returns Promise resolving to the quota and recent-request history
      */

package/dist/index.d.ts

@@ -9,6 +9,7 @@ export * from "./applications";
 export * from "./auth";
 export * from "./buildercodes";
 export * from "./contracts";
+export * from "./copy-trading";
 export * from "./delegated-agents";
 export * from "./faucet";
 export * from "./fees";

package/dist/index.js

@@ -10,6 +10,7 @@ export * from "./applications";
 export * from "./auth";
 export * from "./buildercodes";
 export * from "./contracts";
+export * from "./copy-trading";
 export * from "./delegated-agents";
 export * from "./faucet";
 export * from "./fees";

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

@@ -30,6 +30,12 @@ export interface MarginAccountSummary {
     withdrawableCollateral: string;
     totalPositionNotional: string;
     unrealizedPnl: string;
+    /**
+     * On a risk bucket row, the risk bucket's cash balance (realized closes,
+     * funding, and transfers between a copy account's risk buckets land here),
+     * not trading profit; trading PnL comes from position history and the
+     * portfolio PnL endpoints.
+     */
     realizedPnl: string;
     updatedAt: string;
     /**
@@ -68,6 +74,18 @@ export interface MarginAccountSummary {
      * persisted-fallback reads.
      */
     availableOrderCollateral?: string;
+    /**
+     * Copy trading: present only on a copy risk bucket row (a follow's copy
+     * account — its cross risk bucket and any isolated children). The id of the
+     * follow that funds it, one of your own follows. Absent (the key is
+     * omitted, never null) on every other row.
+     */
+    copyFollowId?: string;
+    /**
+     * Copy trading: on a copy risk bucket row, the followed leader's custom
+     * TraderCode handle, when they still hold one. Absent otherwise.
+     */
+    copyLeaderHandle?: string;
 }
 export interface ListMarginAccountsParams {
     page?: number;

package/dist/portfolio/index.d.ts

@@ -236,6 +236,18 @@ export interface PortfolioRiskBucket {
      * over `riskBuckets`.
      */
     marginMode: MarginMode;
+    /**
+     * Copy trading: present only on a copy risk bucket row (a follow's copy
+     * account — its cross risk bucket and any isolated children). The id of the
+     * follow that funds it, one of your own follows. Absent (the key is
+     * omitted, never null) on every other row.
+     */
+    copyFollowId?: string;
+    /**
+     * Copy trading: on a copy risk bucket row, the followed leader's custom
+     * TraderCode handle, when they still hold one. Absent otherwise.
+     */
+    copyLeaderHandle?: string;
     /**
      * The trading pair this bucket is scoped to. Present for `ISOLATED`
      * buckets; absent (the key is omitted, never null) for `CROSS`, which spans

package/dist/positions/index.d.ts

@@ -66,11 +66,16 @@ export interface Position {
     /**
      * Lifetime realized PnL net of trading fees and funding. Terminal rows
      * only; absent when the position's reducing executions are unavailable.
+     * Deducts whole-life `cumFees` once. Also absent until its final close is
+     * recorded in the PnL sample and fee history is complete; poll again while
+     * pending. With no sample, remains absent for 28 days after close, then
+     * falls back to closing-execution net without unavailable opening fees.
      */
     netRealizedPnl?: string;
     /**
      * Lifetime realized return on the total allocated initial margin, as a
-     * percentage. Terminal rows only; absent when unavailable.
+     * percentage. Terminal rows only; absent when unavailable, including under
+     * the same conditions as `netRealizedPnl`.
      */
     realizedRoe?: string;
     /**
@@ -101,7 +106,8 @@ export interface Position {
      * terminal rows alike. Null when the opening-fill fees are unavailable —
      * before the position's first PnL sample flushes, after its samples age out
      * of PnL retention, or for positions predating the PnL service — rather than
-     * an understated partial.
+     * an understated partial. On a terminal row it is also null until the
+     * final close is recorded in its PnL sample, or while fee data is incomplete.
      */
     cumFees?: string;
     /**

package/dist/profile/index.d.ts

@@ -98,7 +98,10 @@ export type TransactionType = "DEPOSIT" | "WITHDRAWAL" | "TRADE" | "FEE" | "FUND
  * Query parameters for getting user movements
  */
 export interface GetUserMovementsParams {
-    /** Page number (starts from 1) */
+    /**
+     * Page number (starts from 1, at most 10,000 — the last page this listing
+     * counts towards; a larger page is rejected).
+     */
     page?: number;
     /** Number of items per page (max 100) */
     pageSize?: number;
@@ -128,9 +131,17 @@ export interface GetPaginatedUserMovementsResponse {
     page: number;
     /** Items per page */
     pageSize: number;
-    /** Total number of movements in PostgreSQL */
+    /**
+     * Matching movements. Exact up to 10,000 pages of the requested `pageSize`
+     * (`pageSize` x 10,000 rows) and saturates there, so a user with more
+     * matching movements than the listing can page through reads the cap, not
+     * their lifetime total.
+     */
     total: number;
-    /** Total number of pages */
+    /**
+     * Number of pages at the requested `pageSize`. Exact up to 10,000 and
+     * saturates there, the last page this listing can reach.
+     */
     totalPages: number;
 }
 /**
@@ -235,8 +246,21 @@ export interface UserTrade {
     quoteVolume: string;
     /** Side of the trade */
     side: OrderSide;
-    /** Fee paid for this trade (as string to preserve precision) */
+    /**
+     * Total fee paid for this trade (as string to preserve precision). For a
+     * taker this is Monaco's taker fee plus the frontend's builder fee; for a
+     * maker it is the maker fee (negative for a rebate). Equals
+     * `monacoFee + builderFee`.
+     */
     fee: string;
+    /** Monaco's component of `fee`. Absent from servers older than this field. */
+    monacoFee?: string;
+    /**
+     * The frontend's builder fee component of `fee`. Always `"0"` for a maker:
+     * builder fees are charged to takers only. Absent from servers older than
+     * this field.
+     */
+    builderFee?: string;
     /** Timestamp when the trade was executed (ISO string) */
     executedAt: string;
 }
@@ -244,15 +268,7 @@ export interface UserTrade {
  * Query parameters for getting user trades
  */
 export interface GetUserTradesParams {
-    /**
-     * Page number for legacy offset pagination (starts from 1).
-     *
-     * @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 items per page (max 100 in page-number mode, up to 1000 when `pageToken` is present) */
+    /** Number of items per page (max 1000) */
     pageSize?: number;
     /** Filter by trading pair ID (UUID) */
     tradingPairId?: string;
@@ -282,32 +298,8 @@ export interface GetUserTradesParams {
 export interface GetUserTradesResponse {
     /** List of user trades */
     trades: UserTrade[];
-    /**
-     * Current page number.
-     *
-     * @deprecated Only populated by legacy page-number (offset) responses; 0 in
-     * cursor mode. Use `pageToken`/`nextPageToken` pagination instead.
-     */
-    page: number;
     /** Items per page */
     pageSize: number;
-    /**
-     * Total matching trades. In page-number mode it is exact up to
-     * `pageSize` × 10,000 rows and saturates there, so a wallet with more history
-     * than legacy mode can page through reads the cap, not its lifetime total.
-     *
-     * @deprecated Only populated by legacy page-number (offset) responses; 0 in
-     * cursor mode, which has no exact total. Walk `nextPageToken` instead.
-     */
-    total: number;
-    /**
-     * Total pages at this `pageSize`. Exact up to 10,000 in page-number mode and
-     * saturates there, the last page legacy mode can reach.
-     *
-     * @deprecated Only populated by legacy page-number (offset) responses; 0 in
-     * cursor mode, which has no exact total. Walk `nextPageToken` instead.
-     */
-    totalPages: number;
     /**
      * Cursor for the next page. Empty on every page-number (legacy) response —
      * page-number mode never mints a token, full page or not, since resuming
@@ -359,7 +351,10 @@ export interface FundingPayment {
  * Query parameters for listing funding payments.
  */
 export interface ListFundingPaymentsParams {
-    /** Page number (starts from 1) */
+    /**
+     * Page number (starts from 1, at most 10,000 — the last page this listing
+     * counts towards; a larger page is rejected).
+     */
     page?: number;
     /** Number of items per page (max 100) */
     pageSize?: number;
@@ -380,9 +375,17 @@ export interface ListFundingPaymentsResponse {
     page: number;
     /** Items per page */
     pageSize: number;
-    /** Total number of matching records */
+    /**
+     * Matching funding payment records. Exact up to 10,000 pages of the
+     * requested `pageSize` (`pageSize` x 10,000 rows) and saturates there, so a
+     * user with more matching payments than the listing can page through reads
+     * the cap, not their lifetime total.
+     */
     total: number;
-    /** Total number of pages */
+    /**
+     * Number of pages at the requested `pageSize`. Exact up to 10,000 and
+     * saturates there, the last page this listing can reach.
+     */
     totalPages: number;
 }
 /**
@@ -596,7 +599,7 @@ export interface ProfileAPI extends BaseAPI {
      *
      * @param params - Optional query parameters for pagination and filtering
      * @param params.page - Page number (starts from 1)
-     * @param params.limit - Number of items per page (max 100 in page-number mode, up to 1000 when `pageToken` is present)
+     * @param params.limit - Number of items per page (max 1000)
      * @param params.tradingPairId - Filter by trading pair ID (UUID)
      * @returns Promise resolving to paginated trades response
      * @throws ValidationError If pagination params (page/limit) are invalid or tradingPairId is not a valid UUID; this may occur before any network request.

package/dist/sdk/index.d.ts

@@ -2,6 +2,7 @@ import type { Address, PublicClient, TransactionReceipt, WalletClient } from "vi
 import type { ApplicationsAPI } from "../applications";
 import type { AuthAPI, AuthState } from "../auth/index";
 import type { BuildercodesAPI } from "../buildercodes";
+import type { CopyTradingAPI } from "../copy-trading";
 import type { DelegatedAgentsAPI } from "../delegated-agents";
 import type { FaucetAPI } from "../faucet";
 import type { FeesAPI } from "../fees";
@@ -115,12 +116,14 @@ export interface MonacoSDK {
     pitpass: PitpassAPI;
     /** BuilderCodes frontend revenue-share payout API */
     buildercodes: BuildercodesAPI;
+    /** Copy trading API: lead trader profiles and the leaderboard, and your follows */
+    copyTrading: CopyTradingAPI;
     /** Testnet faucet API */
     faucet: FaucetAPI;
     /** Deposit-address registration (sweeper) API; requires a session */
     sweeper: SweeperAPI;
     managedMarkets: ManagedMarketsAPI;
-    /** Public whitelist (waitlist) submission API */
+    /** @deprecated Public whitelist applications are closed; submissions return HTTP 403. */
     whitelist: WhitelistAPI;
     /** Profile operations API */
     profile: ProfileAPI;

package/dist/trading/orders.d.ts

@@ -125,6 +125,12 @@ export interface Order {
      * close means unknown, not "placed by hand". Wire: `conditionalOrderId`.
      */
     conditionalOrderId?: string;
+    /**
+     * Present only on a TWAP child order: the TWAP parent that placed it. The
+     * same id the `orders` WebSocket frames and snapshot rows carry for the
+     * child. Wire: `parentOrderId`.
+     */
+    parentOrderId?: string;
     /**
      * Opaque, compare-only revision counter for this order's state: a strictly
      * higher value is strictly newer state for that order, and equal values