@0xmonaco/types 1.0.69 → 1.0.72

package/dist/auth/index.d.ts

@@ -77,8 +77,10 @@ export interface AuthAPI extends BaseAPI {
      */
     verifySignature(address: string, signature: string, nonce: string, clientId: string, session: SessionCredentials, referralCode?: string): Promise<AuthState>;
     /**
-     * Extends the current session's expiry. The request is signed with the
-     * active session key (set via {@link setSessionKeypair}).
+     * Refreshes the current session's expiry. The request is signed with the
+     * active session key (set via {@link setSessionKeypair}). For a delegated
+     * session, the returned expiry is capped by the active delegation and may
+     * move earlier if the owner shortened that delegation.
      * @returns Promise resolving to the new expiry
      */
     refreshSession(): Promise<SessionRefreshResponse>;

package/dist/auth/responses.d.ts

@@ -78,7 +78,9 @@ export interface SessionCredentials {
     privateKey: string;
 }
 /**
- * Response to a session refresh request — extends the session's expiry.
+ * Response to a session refresh request with the resulting expiry. For a
+ * delegated session, this remains capped by the active delegation and may move earlier
+ * if the owner shortened that delegation.
  */
 export interface SessionRefreshResponse {
     /** Unix timestamp when the session expires after refresh */

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

@@ -0,0 +1,143 @@
+/**
+ * Copy Trading Types (0XM-2851)
+ *
+ * Followers allocate collateral to a per-leader copy account (a cross risk
+ * bucket in their margin account) and every fill the leader makes is mirrored
+ * into it. Leaders are addressed by their custom TraderCode handle.
+ */
+import type { BaseAPI } from "../api";
+import type { AddFollowPositionMarginParams, ListLeadTraderClosedTradesParams, ListLeadTradersParams, ListMyFollowersParams, ListMyFollowsParams, PreviewFollowParams, UpsertFollowParams, UpsertLeadTraderParams } from "../validation/copy-trading";
+import type { AddFollowPositionMarginResponse, CloseAllCopyPositionsResponse, CloseFollowPositionsResponse, GetFollowResponse, GetLeadTraderResponse, ListFollowLeaderPositionsResponse, ListLeadTraderClosedTradesResponse, ListLeadTraderOpenPositionsResponse, ListLeadTradersResponse, ListMyFollowersResponse, ListMyFollowsResponse, PreviewFollowResponse, StopFollowResponse, UpsertFollowResponse, UpsertLeadTraderResponse } from "./responses";
+/**
+ * Copy trading API.
+ *
+ * Public reads (no session needed): {@link listLeadTraders},
+ * {@link getLeadTrader}, {@link listLeadTraderClosedTrades}. Everything else
+ * is self-scoped to the authenticated caller. Delegated agent and sub-account
+ * sessions cannot register as a leader or follow (403).
+ */
+export interface CopyTradingAPI extends BaseAPI {
+    /**
+     * List lead traders (the public leaderboard), highest first by `sort`
+     * (default `roi`) over `window` (default `30d`). Cursor paged: pass the
+     * previous response's `nextPageToken` with the SAME sort and window; an
+     * empty token means the end.
+     */
+    listLeadTraders(params?: ListLeadTradersParams): Promise<ListLeadTradersResponse>;
+    /**
+     * Get one lead trader by custom TraderCode handle: profile, follow summary
+     * and stats for 7d, 30d, 90d and all. 404 for an unknown or suspended
+     * leader.
+     */
+    getLeadTrader(handle: string): Promise<GetLeadTraderResponse>;
+    /** List a lead trader's closed trades (reducing executions), newest first, cursor paged. */
+    listLeadTraderClosedTrades(handle: string, params?: ListLeadTraderClosedTradesParams): Promise<ListLeadTraderClosedTradesResponse>;
+    /** List a lead trader's open positions. Only current followers of that leader may read them (403 otherwise). */
+    listLeadTraderOpenPositions(handle: string): Promise<ListLeadTraderOpenPositionsResponse>;
+    /**
+     * Register as a lead trader, or edit your profile. A registration is
+     * checked against the platform's eligibility rules (account equity, trading
+     * history, closed positions, and a claimed custom TraderCode handle, which
+     * followers address you by); a refusal is a 400 naming the rule. A follower
+     * with a live follow cannot register.
+     *
+     * The profile is replaced as sent: an omitted `bio` or `minAllocation`
+     * clears it and an omitted `status` means `ACTIVE`; an omitted `shareBps`
+     * keeps the current share (the platform default on a registration).
+     */
+    upsertLeadTrader(params?: UpsertLeadTraderParams): Promise<UpsertLeadTraderResponse>;
+    /** Get your own lead trader profile (404 when you are not a lead trader). */
+    getMyLeadTrader(): Promise<GetLeadTraderResponse>;
+    /** List your followers, as a leader. Cursor paged, up to 1000 per page. */
+    listMyFollowers(params?: ListMyFollowersParams): Promise<ListMyFollowersResponse>;
+    /**
+     * Follow a lead trader (no `followId`), or edit one of your follows
+     * (`followId` set). A create moves `allocation` from your margin account
+     * into a new copy account: a cross risk bucket that holds this follow's
+     * collateral and positions.
+     *
+     * An edit REPLACES the follow's settings: every optional setting you leave
+     * out reverts to its default, so an edit that omits `slPct` removes the
+     * stop-loss. Pass the full desired configuration on every edit. The leader
+     * comes from the stored follow, so `leader` may be omitted on an edit; a
+     * handle naming a different leader is refused.
+     */
+    upsertFollow(params: UpsertFollowParams): Promise<UpsertFollowResponse>;
+    /**
+     * Stop one of your follows: the leader's fills stop being mirrored. An exit
+     * is never gated beyond ownership, except that a delegated agent session
+     * cannot stop a follow (403).
+     */
+    stopFollow(followId: string): Promise<StopFollowResponse>;
+    /**
+     * Close every position in one of your follows' copy accounts at market
+     * (reduce-only, immediate-or-cancel) and cancel the resting orders and
+     * conditional orders (TP/SL) on its copy risk buckets, keeping the follow:
+     * the leader's next trades keep mirroring. `stopFollow` is the
+     * close-and-stop path. Proceeds stay in the copy account. Not a flatten
+     * guarantee: a thin or halted market can leave part of a position open
+     * (`positionsNotClosed`), and a leader trade after the close opens copies
+     * again. Never gated by copy trading being off or an operations block; only
+     * a delegated agent session is refused (403). Both close methods share a
+     * small per-account rate limit (about one per second, burst 5; 429 with
+     * Retry-After). 404 for a follow that is not yours; 409 for a stopped
+     * follow or one whose stop is in progress; 400 when the close was refused;
+     * 503 when it cannot run right now. The response is sent once the batch is
+     * durably logged; fills arrive on the order, position and copy channels.
+     */
+    closeFollowPositions(followId: string): Promise<CloseFollowPositionsResponse>;
+    /**
+     * Close the copy positions of every live follow of yours, as
+     * `closeFollowPositions` does for one, keeping the follows. Follows whose
+     * stop is in progress are listed in `stoppingFollowIds`; a follow whose
+     * close could not run is listed in `failedFollows` with a fixed reason
+     * while the others still close.
+     */
+    closeAllCopyPositions(): Promise<CloseAllCopyPositionsResponse>;
+    /**
+     * Add margin to one of your copy positions: moves `amount` (quote units)
+     * from the follow's copy account into the margin of its isolated copy
+     * position on `tradingPairId`. The position's margin rises by exactly
+     * `amount` and the copy account's remaining collateral falls by the same;
+     * your margin account is never touched. It lowers the position's leverage
+     * and moves its liquidation price away, and opens no exposure, so it works
+     * while copy trading is switched off and on a `CLOSE_ONLY` follow. There
+     * is no margin reduction: a follow exits by being stopped.
+     *
+     * Master account sessions only (a delegated agent or a sub-account gets
+     * 403); 404 for a follow that is not yours; 409 while the follow is
+     * stopping or once it is stopped, or `COPY_TRADING_UNAVAILABLE` when copy
+     * trading is not available on the platform; 400 `COPY_TRADING_REJECTED`
+     * when the engine refuses (no isolated copy position on the pair, the
+     * position or the margin account is being liquidated, the position has
+     * lost more than its margin, more than the copy account can put in); 429
+     * over the movement budget withdrawals and collateral transfers share.
+     *
+     * Not idempotent: a retry after a timeout whose first attempt landed adds
+     * the amount twice, so read the follow before retrying.
+     */
+    addFollowPositionMargin(params: AddFollowPositionMarginParams): Promise<AddFollowPositionMarginResponse>;
+    /** List your follows, newest first. Cursor paged, up to 1000 per page. */
+    listMyFollows(params?: ListMyFollowsParams): Promise<ListMyFollowsResponse>;
+    /**
+     * Get one of your follows with its most recent skipped mirrors (up to 100)
+     * and the copy account's marked equity. 404 for a follow that is not yours.
+     */
+    getFollow(followId: string): Promise<GetFollowResponse>;
+    /**
+     * List the open positions of the leader one of your follows copies. The
+     * leader comes from the follow, so this works after the leader releases
+     * their handle. 404 for a follow that is not yours; 403 for a stopped one.
+     */
+    listFollowLeaderPositions(followId: string): Promise<ListFollowLeaderPositionsResponse>;
+    /**
+     * Preview what a follow with these terms would open if it set
+     * `copyExisting`, as totals only: the estimated margin and fees, and how
+     * many of the leader's positions would and would not be copied (no pair,
+     * side or reason). Read-only. Delegated agent and sub-account sessions get
+     * 403, as for following.
+     */
+    previewFollow(params: PreviewFollowParams): Promise<PreviewFollowResponse>;
+}
+export type { AddFollowPositionMarginResponse, CloseAllCopyPositionsResponse, ClosedTrade, ClosedTradeAction, CloseFollowPositionsResponse, CopySkip, Follow, FollowCloseFailure, Follower, GetFollowResponse, GetLeadTraderResponse, LeadTraderFollowSummary, LeadTraderListing, LeadTraderOpenPosition, LeadTraderProfile, LeadTraderRef, LeadTraderSort, LeadTraderStats, LeadTraderStatsWindow, LeadTraderStatus, ListFollowLeaderPositionsResponse, ListLeadTraderClosedTradesResponse, ListLeadTraderOpenPositionsResponse, ListLeadTradersResponse, ListMyFollowersResponse, ListMyFollowsResponse, PreviewFollowResponse, StopFollowResponse, UpsertFollowResponse, UpsertLeadTraderResponse, } from "./responses";
+export { AddFollowPositionMarginResponseSchema, CloseAllCopyPositionsResponseSchema, ClosedTradeSchema, CloseFollowPositionsResponseSchema, CopySkipSchema, FollowCloseFailureSchema, FollowerSchema, FollowSchema, GetFollowResponseSchema, GetLeadTraderResponseSchema, LeadTraderFollowSummarySchema, LeadTraderListingSchema, LeadTraderOpenPositionSchema, LeadTraderProfileSchema, LeadTraderRefSchema, LeadTraderStatsSchema, ListFollowLeaderPositionsResponseSchema, ListLeadTraderClosedTradesResponseSchema, ListLeadTraderOpenPositionsResponseSchema, ListLeadTradersResponseSchema, ListMyFollowersResponseSchema, ListMyFollowsResponseSchema, PreviewFollowResponseSchema, StopFollowResponseSchema, UpsertFollowResponseSchema, UpsertLeadTraderResponseSchema, } from "./responses";

package/dist/copy-trading/index.js

@@ -0,0 +1,8 @@
+/**
+ * Copy Trading Types (0XM-2851)
+ *
+ * Followers allocate collateral to a per-leader copy account (a cross risk
+ * bucket in their margin account) and every fill the leader makes is mirrored
+ * into it. Leaders are addressed by their custom TraderCode handle.
+ */
+export { AddFollowPositionMarginResponseSchema, CloseAllCopyPositionsResponseSchema, ClosedTradeSchema, CloseFollowPositionsResponseSchema, CopySkipSchema, FollowCloseFailureSchema, FollowerSchema, FollowSchema, GetFollowResponseSchema, GetLeadTraderResponseSchema, LeadTraderFollowSummarySchema, LeadTraderListingSchema, LeadTraderOpenPositionSchema, LeadTraderProfileSchema, LeadTraderRefSchema, LeadTraderStatsSchema, ListFollowLeaderPositionsResponseSchema, ListLeadTraderClosedTradesResponseSchema, ListLeadTraderOpenPositionsResponseSchema, ListLeadTradersResponseSchema, ListMyFollowersResponseSchema, ListMyFollowsResponseSchema, PreviewFollowResponseSchema, StopFollowResponseSchema, UpsertFollowResponseSchema, UpsertLeadTraderResponseSchema, } from "./responses";

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

@@ -0,0 +1,416 @@
+/**
+ * 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";
+import type { CopyLeverageMode, CopyMarginModePolicy, CopyRelationshipStatus, CopySizingMode, CopySkipReason, CopyStopReason } from "../websocket/events/copy-events";
+/** Lead trader profile status. `SUSPENDED` appears only on your own profile. */
+export type LeadTraderStatus = "ACTIVE" | "PAUSED" | "SUSPENDED";
+/** Leaderboard stats window. */
+export type LeadTraderStatsWindow = "7d" | "30d" | "90d" | "all";
+/** Leaderboard sort metric (highest first). */
+export type LeadTraderSort = "roi" | "pnl" | "followers" | "allocated" | "aum" | "win_rate";
+/** The kind of reducing execution a closed trade records. */
+export type ClosedTradeAction = "DECREASE" | "CLOSE" | "LIQUIDATE" | "ADL";
+/** A lead trader as the public sees them: wallet and handle, never an internal id. */
+export declare const LeadTraderRefSchema: z.ZodObject<{
+    walletAddress: z.ZodString;
+    handle: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    display: z.ZodString;
+}, z.core.$strip>;
+/** A lead trader's public profile. */
+export declare const LeadTraderProfileSchema: z.ZodObject<{
+    leader: z.ZodObject<{
+        walletAddress: z.ZodString;
+        handle: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        display: z.ZodString;
+    }, z.core.$strip>;
+    status: z.ZodType<(string & {}) | LeadTraderStatus, unknown, z.core.$ZodTypeInternals<(string & {}) | LeadTraderStatus, unknown>>;
+    shareBps: z.ZodNumber;
+    bio: z.ZodString;
+    minAllocation: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    registeredAt: z.ZodString;
+}, z.core.$strip>;
+/** Live follows of a leader. */
+export declare const LeadTraderFollowSummarySchema: z.ZodObject<{
+    followerCount: z.ZodNumber;
+    allocated: z.ZodString;
+    aumEquity: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+/** A leader's trading stats over one window. */
+export declare const LeadTraderStatsSchema: z.ZodObject<{
+    window: z.ZodType<(string & {}) | LeadTraderStatsWindow, unknown, z.core.$ZodTypeInternals<(string & {}) | LeadTraderStatsWindow, unknown>>;
+    pnl: z.ZodString;
+    roiPct: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    maxDrawdownPct: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    winRatePct: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    closedTrades: z.ZodNumber;
+}, z.core.$strip>;
+/** One lead trader: profile, follow summary and stats for every window (7d, 30d, 90d, all). */
+export declare const GetLeadTraderResponseSchema: z.ZodObject<{
+    profile: z.ZodObject<{
+        leader: z.ZodObject<{
+            walletAddress: z.ZodString;
+            handle: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            display: z.ZodString;
+        }, z.core.$strip>;
+        status: z.ZodType<(string & {}) | LeadTraderStatus, unknown, z.core.$ZodTypeInternals<(string & {}) | LeadTraderStatus, unknown>>;
+        shareBps: z.ZodNumber;
+        bio: z.ZodString;
+        minAllocation: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        registeredAt: z.ZodString;
+    }, z.core.$strip>;
+    followSummary: z.ZodObject<{
+        followerCount: z.ZodNumber;
+        allocated: z.ZodString;
+        aumEquity: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>;
+    stats: z.ZodArray<z.ZodObject<{
+        window: z.ZodType<(string & {}) | LeadTraderStatsWindow, unknown, z.core.$ZodTypeInternals<(string & {}) | LeadTraderStatsWindow, unknown>>;
+        pnl: z.ZodString;
+        roiPct: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        maxDrawdownPct: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        winRatePct: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        closedTrades: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** One leaderboard row: stats for the requested window only. */
+export declare const LeadTraderListingSchema: z.ZodObject<{
+    profile: z.ZodObject<{
+        leader: z.ZodObject<{
+            walletAddress: z.ZodString;
+            handle: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            display: z.ZodString;
+        }, z.core.$strip>;
+        status: z.ZodType<(string & {}) | LeadTraderStatus, unknown, z.core.$ZodTypeInternals<(string & {}) | LeadTraderStatus, unknown>>;
+        shareBps: z.ZodNumber;
+        bio: z.ZodString;
+        minAllocation: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        registeredAt: z.ZodString;
+    }, z.core.$strip>;
+    followSummary: z.ZodObject<{
+        followerCount: z.ZodNumber;
+        allocated: z.ZodString;
+        aumEquity: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>;
+    stats: z.ZodObject<{
+        window: z.ZodType<(string & {}) | LeadTraderStatsWindow, unknown, z.core.$ZodTypeInternals<(string & {}) | LeadTraderStatsWindow, unknown>>;
+        pnl: z.ZodString;
+        roiPct: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        maxDrawdownPct: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        winRatePct: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        closedTrades: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/** A page of the public leaderboard. */
+export declare const ListLeadTradersResponseSchema: z.ZodObject<{
+    leaders: z.ZodArray<z.ZodObject<{
+        profile: z.ZodObject<{
+            leader: z.ZodObject<{
+                walletAddress: z.ZodString;
+                handle: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                display: z.ZodString;
+            }, z.core.$strip>;
+            status: z.ZodType<(string & {}) | LeadTraderStatus, unknown, z.core.$ZodTypeInternals<(string & {}) | LeadTraderStatus, unknown>>;
+            shareBps: z.ZodNumber;
+            bio: z.ZodString;
+            minAllocation: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            registeredAt: z.ZodString;
+        }, z.core.$strip>;
+        followSummary: z.ZodObject<{
+            followerCount: z.ZodNumber;
+            allocated: z.ZodString;
+            aumEquity: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>;
+        stats: z.ZodObject<{
+            window: z.ZodType<(string & {}) | LeadTraderStatsWindow, unknown, z.core.$ZodTypeInternals<(string & {}) | LeadTraderStatsWindow, unknown>>;
+            pnl: z.ZodString;
+            roiPct: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            maxDrawdownPct: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            winRatePct: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            closedTrades: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    nextPageToken: z.ZodString;
+    asOf: z.ZodString;
+}, z.core.$strip>;
+/** Result of registering as, or editing, a lead trader. */
+export declare const UpsertLeadTraderResponseSchema: z.ZodObject<{
+    created: z.ZodBoolean;
+    status: z.ZodType<(string & {}) | LeadTraderStatus, unknown, z.core.$ZodTypeInternals<(string & {}) | LeadTraderStatus, unknown>>;
+    shareBps: z.ZodNumber;
+}, z.core.$strip>;
+/** One of your followers, as a leader sees them. */
+export declare const FollowerSchema: z.ZodObject<{
+    walletAddress: z.ZodString;
+    display: z.ZodString;
+    status: z.ZodType<CopyRelationshipStatus | (string & {}), unknown, z.core.$ZodTypeInternals<CopyRelationshipStatus | (string & {}), unknown>>;
+    allocation: z.ZodString;
+    startedAt: z.ZodString;
+}, z.core.$strip>;
+/** A page of your followers. */
+export declare const ListMyFollowersResponseSchema: z.ZodObject<{
+    followers: z.ZodArray<z.ZodObject<{
+        walletAddress: z.ZodString;
+        display: z.ZodString;
+        status: z.ZodType<CopyRelationshipStatus | (string & {}), unknown, z.core.$ZodTypeInternals<CopyRelationshipStatus | (string & {}), unknown>>;
+        allocation: z.ZodString;
+        startedAt: z.ZodString;
+    }, z.core.$strip>>;
+    nextPageToken: z.ZodString;
+}, z.core.$strip>;
+/** One reducing execution of a leader's position. */
+export declare const ClosedTradeSchema: z.ZodObject<{
+    tradingPairId: z.ZodString;
+    positionSide: z.ZodString;
+    action: z.ZodType<(string & {}) | ClosedTradeAction, unknown, z.core.$ZodTypeInternals<(string & {}) | ClosedTradeAction, unknown>>;
+    size: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    exitPrice: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    entryPrice: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    realizedPnl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    netRealizedPnl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    realizedRoe: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    closedAt: z.ZodString;
+}, z.core.$strip>;
+/** A page of a leader's closed trades. */
+export declare const ListLeadTraderClosedTradesResponseSchema: z.ZodObject<{
+    closedTrades: z.ZodArray<z.ZodObject<{
+        tradingPairId: z.ZodString;
+        positionSide: z.ZodString;
+        action: z.ZodType<(string & {}) | ClosedTradeAction, unknown, z.core.$ZodTypeInternals<(string & {}) | ClosedTradeAction, unknown>>;
+        size: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        exitPrice: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        entryPrice: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        realizedPnl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        netRealizedPnl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        realizedRoe: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        closedAt: z.ZodString;
+    }, z.core.$strip>>;
+    nextPageToken: z.ZodString;
+}, z.core.$strip>;
+/** One open position of a leader you follow. */
+export declare const LeadTraderOpenPositionSchema: z.ZodObject<{
+    tradingPairId: z.ZodString;
+    side: z.ZodString;
+    size: z.ZodString;
+    entryPrice: z.ZodString;
+    markPrice: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    unrealizedPnl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    leverage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    marginMode: z.ZodString;
+}, z.core.$strip>;
+/** A followed leader's open positions (current followers only). */
+export declare const ListLeadTraderOpenPositionsResponseSchema: z.ZodObject<{
+    positions: z.ZodArray<z.ZodObject<{
+        tradingPairId: z.ZodString;
+        side: z.ZodString;
+        size: z.ZodString;
+        entryPrice: z.ZodString;
+        markPrice: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        unrealizedPnl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        leverage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        marginMode: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** One of your follows. */
+export declare const FollowSchema: z.ZodObject<{
+    followId: z.ZodString;
+    leader: z.ZodObject<{
+        walletAddress: z.ZodString;
+        handle: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        display: z.ZodString;
+    }, z.core.$strip>;
+    status: z.ZodType<CopyRelationshipStatus | (string & {}), unknown, z.core.$ZodTypeInternals<CopyRelationshipStatus | (string & {}), unknown>>;
+    marginModePolicy: z.ZodType<CopyMarginModePolicy | (string & {}), unknown, z.core.$ZodTypeInternals<CopyMarginModePolicy | (string & {}), unknown>>;
+    sizingMode: z.ZodType<CopySizingMode | (string & {}), unknown, z.core.$ZodTypeInternals<CopySizingMode | (string & {}), unknown>>;
+    sizingParam: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    leverageMode: z.ZodType<CopyLeverageMode | (string & {}), unknown, z.core.$ZodTypeInternals<CopyLeverageMode | (string & {}), unknown>>;
+    fixedLeverage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    allocation: z.ZodString;
+    slPct: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    copyExisting: z.ZodBoolean;
+    tradingPairIds: z.ZodArray<z.ZodString>;
+    consecutiveSkips: z.ZodNumber;
+    copyRiskBucketId: z.ZodString;
+    startedAt: z.ZodString;
+    stoppedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    stopReason: z.ZodOptional<z.ZodNullable<z.ZodType<CopyStopReason | (string & {}), unknown, z.core.$ZodTypeInternals<CopyStopReason | (string & {}), unknown>>>>;
+}, z.core.$strip>;
+/** A page of your follows. */
+export declare const ListMyFollowsResponseSchema: z.ZodObject<{
+    follows: z.ZodArray<z.ZodObject<{
+        followId: z.ZodString;
+        leader: z.ZodObject<{
+            walletAddress: z.ZodString;
+            handle: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            display: z.ZodString;
+        }, z.core.$strip>;
+        status: z.ZodType<CopyRelationshipStatus | (string & {}), unknown, z.core.$ZodTypeInternals<CopyRelationshipStatus | (string & {}), unknown>>;
+        marginModePolicy: z.ZodType<CopyMarginModePolicy | (string & {}), unknown, z.core.$ZodTypeInternals<CopyMarginModePolicy | (string & {}), unknown>>;
+        sizingMode: z.ZodType<CopySizingMode | (string & {}), unknown, z.core.$ZodTypeInternals<CopySizingMode | (string & {}), unknown>>;
+        sizingParam: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        leverageMode: z.ZodType<CopyLeverageMode | (string & {}), unknown, z.core.$ZodTypeInternals<CopyLeverageMode | (string & {}), unknown>>;
+        fixedLeverage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        allocation: z.ZodString;
+        slPct: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        copyExisting: z.ZodBoolean;
+        tradingPairIds: z.ZodArray<z.ZodString>;
+        consecutiveSkips: z.ZodNumber;
+        copyRiskBucketId: z.ZodString;
+        startedAt: z.ZodString;
+        stoppedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        stopReason: z.ZodOptional<z.ZodNullable<z.ZodType<CopyStopReason | (string & {}), unknown, z.core.$ZodTypeInternals<CopyStopReason | (string & {}), unknown>>>>;
+    }, z.core.$strip>>;
+    nextPageToken: z.ZodString;
+}, z.core.$strip>;
+/** A leader fill one of your follows did not mirror. */
+export declare const CopySkipSchema: z.ZodObject<{
+    tradingPairId: z.ZodString;
+    reason: z.ZodType<CopySkipReason | (string & {}), unknown, z.core.$ZodTypeInternals<CopySkipReason | (string & {}), unknown>>;
+    requestedQuantity: z.ZodString;
+    skippedAt: z.ZodString;
+}, z.core.$strip>;
+/** One of your follows with its most recent skips (up to 100). */
+export declare const GetFollowResponseSchema: z.ZodObject<{
+    follow: z.ZodObject<{
+        followId: z.ZodString;
+        leader: z.ZodObject<{
+            walletAddress: z.ZodString;
+            handle: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            display: z.ZodString;
+        }, z.core.$strip>;
+        status: z.ZodType<CopyRelationshipStatus | (string & {}), unknown, z.core.$ZodTypeInternals<CopyRelationshipStatus | (string & {}), unknown>>;
+        marginModePolicy: z.ZodType<CopyMarginModePolicy | (string & {}), unknown, z.core.$ZodTypeInternals<CopyMarginModePolicy | (string & {}), unknown>>;
+        sizingMode: z.ZodType<CopySizingMode | (string & {}), unknown, z.core.$ZodTypeInternals<CopySizingMode | (string & {}), unknown>>;
+        sizingParam: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        leverageMode: z.ZodType<CopyLeverageMode | (string & {}), unknown, z.core.$ZodTypeInternals<CopyLeverageMode | (string & {}), unknown>>;
+        fixedLeverage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        allocation: z.ZodString;
+        slPct: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        copyExisting: z.ZodBoolean;
+        tradingPairIds: z.ZodArray<z.ZodString>;
+        consecutiveSkips: z.ZodNumber;
+        copyRiskBucketId: z.ZodString;
+        startedAt: z.ZodString;
+        stoppedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        stopReason: z.ZodOptional<z.ZodNullable<z.ZodType<CopyStopReason | (string & {}), unknown, z.core.$ZodTypeInternals<CopyStopReason | (string & {}), unknown>>>>;
+    }, z.core.$strip>;
+    recentSkips: z.ZodArray<z.ZodObject<{
+        tradingPairId: z.ZodString;
+        reason: z.ZodType<CopySkipReason | (string & {}), unknown, z.core.$ZodTypeInternals<CopySkipReason | (string & {}), unknown>>;
+        requestedQuantity: z.ZodString;
+        skippedAt: z.ZodString;
+    }, z.core.$strip>>;
+    copyAccountEquity: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+/** The open positions of the leader one of your follows copies. */
+export declare const ListFollowLeaderPositionsResponseSchema: z.ZodObject<{
+    positions: z.ZodArray<z.ZodObject<{
+        tradingPairId: z.ZodString;
+        side: z.ZodString;
+        size: z.ZodString;
+        entryPrice: z.ZodString;
+        markPrice: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        unrealizedPnl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        leverage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        marginMode: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** Result of following a leader or editing a follow. */
+export declare const UpsertFollowResponseSchema: z.ZodObject<{
+    followId: z.ZodString;
+    copyRiskBucketId: z.ZodString;
+    created: z.ZodBoolean;
+}, z.core.$strip>;
+/**
+ * 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 declare const PreviewFollowResponseSchema: z.ZodObject<{
+    estimatedMargin: z.ZodString;
+    estimatedFee: z.ZodString;
+    copiedPositions: z.ZodNumber;
+    skippedPositions: z.ZodNumber;
+    truncated: z.ZodBoolean;
+}, z.core.$strip>;
+/** Result of stopping a follow. */
+export declare const StopFollowResponseSchema: z.ZodObject<{
+    followId: z.ZodString;
+}, z.core.$strip>;
+/**
+ * One follow's copy positions closing: a batch acknowledgement, sent once the
+ * batch is durably logged. The closes are reduce-only and immediate-or-cancel;
+ * each one's fills arrive on the order, position and copy channels. Not a
+ * flatten guarantee: `positionsNotClosed` counts what a thin or halted market
+ * left open.
+ */
+export declare const CloseFollowPositionsResponseSchema: z.ZodObject<{
+    followId: z.ZodString;
+    closeOrdersPlaced: z.ZodNumber;
+    positionsNotClosed: z.ZodNumber;
+}, z.core.$strip>;
+/** A follow whose close could not run. */
+export declare const FollowCloseFailureSchema: z.ZodObject<{
+    followId: z.ZodString;
+    reason: z.ZodString;
+}, z.core.$strip>;
+/** Result of closing all your copy positions. */
+export declare const CloseAllCopyPositionsResponseSchema: z.ZodObject<{
+    follows: z.ZodArray<z.ZodObject<{
+        followId: z.ZodString;
+        closeOrdersPlaced: z.ZodNumber;
+        positionsNotClosed: z.ZodNumber;
+    }, z.core.$strip>>;
+    stoppingFollowIds: z.ZodArray<z.ZodString>;
+    failedFollows: z.ZodArray<z.ZodObject<{
+        followId: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** Result of adding margin to one of your copy positions. */
+export declare const AddFollowPositionMarginResponseSchema: z.ZodObject<{
+    followId: z.ZodString;
+    tradingPairId: z.ZodString;
+    riskBucketId: z.ZodString;
+    positionId: z.ZodString;
+    positionMargin: z.ZodString;
+    copyAccountAvailable: z.ZodString;
+}, z.core.$strip>;
+export type LeadTraderRef = z.infer<typeof LeadTraderRefSchema>;
+export type LeadTraderProfile = z.infer<typeof LeadTraderProfileSchema>;
+export type LeadTraderFollowSummary = z.infer<typeof LeadTraderFollowSummarySchema>;
+export type LeadTraderStats = z.infer<typeof LeadTraderStatsSchema>;
+export type GetLeadTraderResponse = z.infer<typeof GetLeadTraderResponseSchema>;
+export type LeadTraderListing = z.infer<typeof LeadTraderListingSchema>;
+export type ListLeadTradersResponse = z.infer<typeof ListLeadTradersResponseSchema>;
+export type UpsertLeadTraderResponse = z.infer<typeof UpsertLeadTraderResponseSchema>;
+export type Follower = z.infer<typeof FollowerSchema>;
+export type ListMyFollowersResponse = z.infer<typeof ListMyFollowersResponseSchema>;
+export type ClosedTrade = z.infer<typeof ClosedTradeSchema>;
+export type ListLeadTraderClosedTradesResponse = z.infer<typeof ListLeadTraderClosedTradesResponseSchema>;
+export type LeadTraderOpenPosition = z.infer<typeof LeadTraderOpenPositionSchema>;
+export type ListLeadTraderOpenPositionsResponse = z.infer<typeof ListLeadTraderOpenPositionsResponseSchema>;
+export type Follow = z.infer<typeof FollowSchema>;
+export type ListMyFollowsResponse = z.infer<typeof ListMyFollowsResponseSchema>;
+export type CopySkip = z.infer<typeof CopySkipSchema>;
+export type GetFollowResponse = z.infer<typeof GetFollowResponseSchema>;
+export type ListFollowLeaderPositionsResponse = z.infer<typeof ListFollowLeaderPositionsResponseSchema>;
+export type UpsertFollowResponse = z.infer<typeof UpsertFollowResponseSchema>;
+export type StopFollowResponse = z.infer<typeof StopFollowResponseSchema>;
+export type CloseFollowPositionsResponse = z.infer<typeof CloseFollowPositionsResponseSchema>;
+export type FollowCloseFailure = z.infer<typeof FollowCloseFailureSchema>;
+export type CloseAllCopyPositionsResponse = z.infer<typeof CloseAllCopyPositionsResponseSchema>;
+export type PreviewFollowResponse = z.infer<typeof PreviewFollowResponseSchema>;
+export type AddFollowPositionMarginResponse = z.infer<typeof AddFollowPositionMarginResponseSchema>;