@0xmonaco/types 1.0.60 → 1.0.62

package/dist/wire/schema.d.ts

@@ -2166,6 +2166,61 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/pitpass/referrals/me": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get your referral position
+         * @description Read your own referral position (self-scoped).
+         *
+         *      Return the authenticated caller's referral position: their direct (L1)
+         *      referrer, the total rewards they have earned, and their most recent reward
+         *      rows. Self-scoped — identity comes only from the session, never a path id,
+         *      so a caller can only ever read their own chain. Every other user is
+         *      identified by their public wallet address, never an internal id. An empty
+         *      `referrer` means the caller was not referred.
+         */
+        get: operations["get_my_referral_position"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/pitpass/referrals/me/downline": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get your referral downline and earnings
+         * @description Read your own downline earnings (self-scoped).
+         *
+         *      Return who the authenticated caller earns from and how much: an
+         *      earnings-by-source breakdown aggregated from the caller's reward rows across
+         *      all three reward levels (L1/L2/L3), their L1 direct-referee roster (including
+         *      referees who have not traded yet), and a per-level earnings summary.
+         *      Self-scoped — identity comes only from the session, never a path id. Every
+         *      source and referee is identified by their public wallet address, never an
+         *      internal id.
+         */
+        get: operations["get_my_referral_downline"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/pitpass/rewards/balance": {
         parameters: {
             query?: never;
@@ -3246,7 +3301,7 @@ export interface components {
              */
             price?: string | null;
             /**
-             * @description New TOTAL quantity (if changing). On a partially filled order the replacement rests total minus filled, and collateral is locked for that remainder only (FIX cancel/replace convention: LeavesQty = OrderQty - CumQty). Must exceed the filled amount. Omitted, the replacement keeps the unfilled remainder.
+             * @description New TOTAL quantity (if changing). On a partially filled order the replacement rests total minus filled, and collateral is locked for that remainder only (FIX cancel/replace convention: LeavesQty = OrderQty - CumQty). Must exceed the filled amount. Omitted, the replacement keeps the unfilled remainder. Margin reduce-only orders are the exception: their quantity is a close size measured against the live position, placed as given, with no subtraction and no must-exceed-filled rule.
              * @example 0.7
              */
             quantity?: string | null;
@@ -4811,6 +4866,33 @@ export interface components {
             /** @description Six-row fee schedule for the requested pair, ascending by tier */
             feeSchedule?: components["schemas"]["FeeTierScheduleRow"][] | null;
         };
+        GetMyReferralDownlineResponse: {
+            /** @description One row per (source trader, level, token) the caller earns from, across all three reward levels. Comes straight from the caller's reward rows — no tree walk. */
+            earningsBySource?: components["schemas"]["ReferralEarningsSource"][] | null;
+            /** @description The caller's direct (L1) referees, newest first, including referees who have not traded yet (0 earned). Bounded to the most recent 500 EFFECTIVE referees (after per-wallet dedupe and the winning-edge filter). The earnings views (`earnings_by_source` and the summary) are unbounded and count every level, so a caller past the roster cap still sees their full earnings; only this roster listing is capped. */
+            directReferees?: components["schemas"]["ReferralDirectReferee"][] | null;
+            /** @description Total earned broken down by level (L1/L2/L3). */
+            summary?: components["schemas"]["ReferralEarningsSummary"] | null;
+        };
+        GetMyReferralPositionResponse: {
+            /**
+             * @description Public wallet address of the caller's direct (L1) referrer — who referred them. Empty when the caller was not referred. Never exposes L2/L3 upline or any internal id.
+             * @example 0x0000000000000000000000000000000000000002
+             */
+            referrer?: string | null;
+            /**
+             * @description Total reward amount the caller has earned, summed across every level and token, in RAW atomic units.
+             * @example 1400000
+             */
+            totalEarned?: string | null;
+            /**
+             * @description Human-facing name for the referrer: their custom TraderCode handle when they have claimed one, otherwise the wallet address (same as `referrer`). Empty when the caller was not referred. Render this instead of raw hex.
+             * @example cooltrader123
+             */
+            referrerDisplay?: string | null;
+            /** @description The caller's most recent reward rows, newest first. Bounded server-side — not the full history. */
+            rewards?: components["schemas"]["ReferralRewardEntry"][] | null;
+        };
         /** @description Latest public open interest for a trading pair. */
         GetOpenInterestResponse: {
             /**
@@ -5141,12 +5223,25 @@ export interface components {
             tradingPairId?: string | null;
             symbol?: string | null;
             minLeverage?: string | null;
+            /**
+             * @description Tier-1 maximum leverage: the cap for a position in the lowest notional bracket. Larger positions are capped by their own bracket in riskTiers.
+             * @example 50
+             */
             maxLeverage?: string | null;
+            /**
+             * @description Tier-1 initial-margin floor rate, as a decimal fraction. Mirrors riskTiers[0].initialMarginRatio; use the active bracket's rate and deduction for the ladder floor. Selected leverage can produce a higher position initial-margin requirement.
+             * @example 0.02
+             */
             initialMarginRatio?: string | null;
+            /**
+             * @description Tier-1 maintenance-margin rate, as a decimal fraction. Mirrors riskTiers[0].maintenanceMarginRatio; use the active bracket's rate and deduction to calculate maintenance margin.
+             * @example 0.01
+             */
             maintenanceMarginRatio?: string | null;
             /** Format: uint32 */
             fundingIntervalSeconds?: number | null;
             liquidationFeeBps?: string | null;
+            /** @description The market's full margin ladder, ascending by lowerBoundNotional and always non-empty (a market with no configured brackets reports a single tier). A position's bracket is the LAST tier whose lowerBoundNotional is at or below its notional, abs(quantity) x markPrice. */
             riskTiers?: components["schemas"]["RiskTier"][] | null;
             updatedAt?: string | null;
         };
@@ -6015,7 +6110,7 @@ export interface components {
             movements?: components["schemas"]["ApplicationMovement"][] | null;
             /**
              * Format: uint32
-             * @description Total matching movements
+             * @description Matching movements. Exact up to 10,000 pages of the requested page size (page_size x 10,000 rows) and saturates there, so an application with more matching movements than the listing can page through reads the cap, not its lifetime total.
              * @example 150
              */
             total?: number | null;
@@ -6033,7 +6128,7 @@ export interface components {
             pageSize?: number | null;
             /**
              * Format: uint32
-             * @description Total number of pages
+             * @description Number of pages at the requested page size. Exact up to 10,000 and saturates there, the last page this listing can reach.
              * @example 8
              */
             totalPages?: number | null;
@@ -6042,7 +6137,7 @@ export interface components {
             orders?: components["schemas"]["ApplicationOrder"][] | null;
             /**
              * Format: uint32
-             * @description Total matching orders
+             * @description Matching orders. Exact up to 10,000 pages of the requested page size (page_size x 10,000 rows) and saturates there, so an application with more matching orders than the listing can page through reads the cap, not its lifetime total.
              * @example 150
              */
             total?: number | null;
@@ -6060,7 +6155,7 @@ export interface components {
             pageSize?: number | null;
             /**
              * Format: uint32
-             * @description Total number of pages
+             * @description Number of pages at the requested page size. Exact up to 10,000 and saturates there, the last page this listing can reach.
              * @example 8
              */
             totalPages?: number | null;
@@ -7282,6 +7377,136 @@ export interface components {
              */
             relevance?: number | null;
         };
+        /** @description One direct (L1) referee of the caller, whether or not they have traded yet. */
+        ReferralDirectReferee: {
+            /**
+             * @description Public wallet address of the direct referee. Never an internal id.
+             * @example 0x0000000000000000000000000000000000000002
+             */
+            wallet?: string | null;
+            /**
+             * @description RFC 3339 timestamp when the referral relationship was recorded (the referee's sign-up under the caller).
+             * @example 2026-07-07T18:00:00Z
+             */
+            referredAt?: string | null;
+            /**
+             * @description Total the caller has earned from this referee's own (L1) trades, in RAW atomic units. `0` for a referee who has not traded yet.
+             * @example 900000
+             */
+            totalEarned?: string | null;
+            /**
+             * @description Human-facing name for the referee: their custom TraderCode handle when they have claimed one, otherwise the wallet address (same as `wallet`). Render this instead of raw hex.
+             * @example cooltrader123
+             */
+            display?: string | null;
+        };
+        /**
+         * @description One aggregated earnings row per (source trader, level, token) the caller
+         *      earns from.
+         */
+        ReferralEarningsSource: {
+            /**
+             * @description Public wallet address of the trader (taker) the caller earns from. Never an internal id.
+             * @example 0x0000000000000000000000000000000000000002
+             */
+            source?: string | null;
+            /**
+             * Format: int32
+             * @description Referral level the caller earns from this source at: 1 (direct), 2, or 3.
+             * @example 1
+             */
+            level?: number | null;
+            /**
+             * @description Total earned from this source at this level and token, in RAW atomic units.
+             * @example 900000
+             */
+            totalEarned?: string | null;
+            /**
+             * @description Reward token contract address (0x-prefixed).
+             * @example 0x0000000000000000000000000000000000000002
+             */
+            token?: string | null;
+            /**
+             * @description Human-facing name for the source: their custom TraderCode handle when they have claimed one, otherwise the wallet address (same as `source`). Render this instead of raw hex.
+             * @example cooltrader123
+             */
+            sourceDisplay?: string | null;
+        };
+        /**
+         * @description Per-level breakdown of the caller's total referral earnings.
+         *
+         *      These are ALL-TIME CREDITED earnings — a raw sum of the immutable
+         *      `referral_rewards` audit rows — and match the `total_earned` on the referral
+         *      position. They are NOT the caller's current spendable rewards balance:
+         *      `GetRewardsBalance` reports the live bucket, which `TransferRewards` draws
+         *      down, so the two diverge after any transfer. Read the rewards balance for
+         *      current availability. Denominated in the single reward token's atomic units
+         *      (Monaco pays PitPass rewards in one token — the quote asset); if a deployment
+         *      ever pays in more than one reward token, atomic units across tokens are not
+         *      additive, so read the per-token `earnings_by_source` rows for a correct
+         *      breakdown.
+         */
+        ReferralEarningsSummary: {
+            /**
+             * @description All-time credited earnings across all levels, in the reward token's RAW atomic units (see the message note — this is not the spendable rewards balance).
+             * @example 1400000
+             */
+            totalEarned?: string | null;
+            /**
+             * @description Total earned from direct (L1) referees, in RAW atomic units.
+             * @example 900000
+             */
+            level1Earned?: string | null;
+            /**
+             * @description Total earned from L2 downline, in RAW atomic units.
+             * @example 400000
+             */
+            level2Earned?: string | null;
+            /**
+             * @description Total earned from L3 downline, in RAW atomic units.
+             * @example 100000
+             */
+            level3Earned?: string | null;
+        };
+        /** @description A single reward the caller has earned, one row per referred trade × level. */
+        ReferralRewardEntry: {
+            /**
+             * @description Public wallet address of the trader (taker) whose trade generated this reward. Never an internal id.
+             * @example 0x0000000000000000000000000000000000000002
+             */
+            source?: string | null;
+            /**
+             * Format: int32
+             * @description Referral level this reward was paid at: 1 (direct, 30%), 2 (15%), or 3 (5%).
+             * @example 1
+             */
+            level?: number | null;
+            /**
+             * @description Reward amount, in RAW atomic units of the token.
+             * @example 1200000
+             */
+            amount?: string | null;
+            /**
+             * @description Reward token contract address (0x-prefixed).
+             * @example 0x0000000000000000000000000000000000000002
+             */
+            token?: string | null;
+            /**
+             * @description The referral rate applied to the source's fee for this reward, as a decimal fraction (e.g. `0.30` for L1).
+             * @example 0.30
+             */
+            rateApplied?: string | null;
+            /**
+             * @description RFC 3339 timestamp when the reward row was recorded.
+             * @example 2026-07-07T18:00:00Z
+             */
+            createdAt?: string | null;
+            /**
+             * @description Human-facing name for the source: their custom TraderCode handle when they have claimed one, otherwise the wallet address (same as `source`). Render this instead of raw hex.
+             * @example cooltrader123
+             */
+            sourceDisplay?: string | null;
+        };
         RefreshManagedMarketQuotesRequest: {
             launchId?: string | null;
             ownerId?: string | null;
@@ -7336,7 +7561,7 @@ export interface components {
              */
             price?: string | null;
             /**
-             * @description New TOTAL quantity (if changing). On a partially filled order the replacement rests total minus filled, and collateral is locked for that remainder only (FIX cancel/replace convention: LeavesQty = OrderQty - CumQty). Must exceed the filled amount. Omitted, the replacement keeps the unfilled remainder.
+             * @description New TOTAL quantity (if changing). On a partially filled order the replacement rests total minus filled, and collateral is locked for that remainder only (FIX cancel/replace convention: LeavesQty = OrderQty - CumQty). Must exceed the filled amount. Omitted, the replacement keeps the unfilled remainder. Margin reduce-only orders are the exception: their quantity is a close size measured against the live position, placed as given, with no subtraction and no must-exceed-filled rule.
              * @example 0.7
              */
             quantity?: string | null;
@@ -7409,16 +7634,56 @@ export interface components {
              */
             available?: string | null;
         };
+        /**
+         * @description One notional bracket of a market's margin ladder. Brackets are MARGINAL:
+         *      a bracket's rate applies only to the notional inside it, and the deduction
+         *      carries the cheaper margin already charged by the brackets below, so margin
+         *      is continuous across every bound rather than jumping at it.
+         */
         RiskTier: {
+            /**
+             * @description Marginal initial-margin floor rate for notional inside this bracket, as a decimal fraction. The ladder floor is IM_floor(N) = N x initialMarginRatio - initialMarginDeduction. A position's initial-margin requirement is the greater of this floor and its selected-leverage initial margin scaled to the current mark.
+             * @example 0.04
+             */
             initialMarginRatio?: string | null;
+            /**
+             * @description Marginal maintenance-margin rate for notional inside this bracket, as a decimal fraction. Maintenance margin for a position of notional N in this bracket is MM(N) = N x maintenanceMarginRatio - maintenanceMarginDeduction.
+             * @example 0.02
+             */
             maintenanceMarginRatio?: string | null;
             /**
              * @deprecated
              * @description DEPRECATED compatibility alias. This value is a maximum absolute base-asset quantity, not a notional. Use maxPositionSize.
              */
             maxPositionNotional?: string | null;
-            /** @description Maximum authoritative absolute position size in base-asset quantity. */
+            /** @description Maximum authoritative absolute position size in base-asset quantity. A market-wide cap, repeated on every tier rather than varying per bracket. */
             maxPositionSize?: string | null;
+            /**
+             * Format: uint32
+             * @description 1-based bracket index within the market's ladder; 1 is the lowest bracket.
+             * @example 2
+             */
+            tierLevel?: number | null;
+            /**
+             * @description USD notional at which this bracket starts, inclusive; "0" for tier 1.
+             * @example 100000000
+             */
+            lowerBoundNotional?: string | null;
+            /**
+             * @description Maximum leverage available inside this bracket. Absent only for a single-tier market configured from explicit margin rates rather than from a leverage.
+             * @example 25
+             */
+            maxLeverage?: string | null;
+            /**
+             * @description Continuity term of the ladder's initial-margin floor formula IM_floor(N) = N x initialMarginRatio - initialMarginDeduction; "0" for tier 1.
+             * @example 2000000
+             */
+            initialMarginDeduction?: string | null;
+            /**
+             * @description Continuity term of the maintenance-margin formula MM(N) = N x maintenanceMarginRatio - maintenanceMarginDeduction; "0" for tier 1.
+             * @example 1000000
+             */
+            maintenanceMarginDeduction?: string | null;
         };
         /** @description Per-pair screener row. Window fields null when insufficient history. */
         ScreenerItem: {
@@ -7676,6 +7941,11 @@ export interface components {
             /** @description Required for normal orders; optional and ignored for reduce-only. */
             leverage?: string | null;
             reduceOnly?: boolean | null;
+            /**
+             * Format: int32
+             * @description MARKET only: client slippage tolerance in basis points, 0..1000, the same rule placement enforces — a LIMIT or IOC preview carrying it is rejected. Tightens the previewed walk to the band the real order will run under and never widens it; omit for the placement default.
+             */
+            slippageToleranceBps?: number | null;
         };
         SimulateOrderRiskResponse: {
             accepted?: boolean | null;
@@ -7739,6 +8009,66 @@ export interface components {
              *      previewed pair.
              */
             selectedTradingPairIds?: string[] | null;
+            /**
+             * @description The simulated match the engine ran to admit this order (0XM-2746): the
+             *      same `MatchResult` shape `CreateOrderResponse.match_result` carries for a
+             *      real placement, produced by the same `simulate_match_with_stp` walk over
+             *      the live book at the moment of the preview — under the caller's
+             *      `slippage_tolerance_bps` merged tighter-wins with the mandatory 1,000 bps
+             *      protective band, the caller's own self-trade-prevention default (the
+             *      preview runs under the caller's wallet, as placement does) and
+             *      reduce-only sizing. Not a handler-side re-walk of an orderbook snapshot,
+             *      so a preflight and the placement it precedes read the same numbers — the
+             *      reason this rides the risk simulation rather than a separate quote
+             *      endpoint. What a preview cannot carry: a post-only flag, TP/SL legs and a
+             *      per-order self-trade-prevention override, so a post-only placement that
+             *      would cross is refused by placement, not by this preview.
+             *
+             *      Fields: `total_filled` is what the walk fills; `remaining_quantity` what
+             *      it could NOT fill inside the merged band — the partial-fill / band-cut
+             *      indicator (0 means the whole size executes; a MARKET preview with a
+             *      non-zero remainder comes back partially filled when placed);
+             *      `average_fill_price` is the quantity-weighted fill price and
+             *      `execution_price_range.worst_price` the worst level reached (highest ask a
+             *      BUY takes, lowest bid a SELL hits), both absent when nothing crosses;
+             *      `status` is the status placement would end in: FILLED for a full fill,
+             *      CANCELLED for a MARKET order the band or the depth cuts short (a MARKET
+             *      remainder cannot rest, so the fills execute and the rest is cancelled —
+             *      read `remaining_quantity` for the partial fill), SUBMITTED for a LIMIT
+             *      that rests, PARTIALLY_FILLED for a LIMIT that crosses partly and rests
+             *      the remainder; `actual_slippage_bps` the realized
+             *      slippage against `reference_price` as the engine computes it for a
+             *      placement, absent when nothing crosses; `max_slippage_bps` echoes the
+             *      caller's tolerance, not the merged band. A LIMIT preview that would rest
+             *      reports 0 filled, the full size remaining and no prices.
+             *
+             *      For a LIMIT or IOC preview the engine measures slippage against the LIMIT
+             *      price and reports none when every fill improved on it, exactly as the
+             *      placement's `match_result` does; `reference_price` below is therefore
+             *      published for MARKET previews only.
+             *
+             *      Priced against the book RIGHT NOW. For a take-profit / stop-loss the close
+             *      runs later, on a different book, under the wider 1,200 bps band the engine
+             *      stamps on a triggered market leg and anchored at trigger time — so for a
+             *      TP/SL estimate apply `actual_slippage_bps` to the TRIGGER price as an
+             *      impact figure rather than displaying this call's absolute average price.
+             *      Fees for this walk are `estimated_fee` above, at the caller's own tier,
+             *      which can lag the engine's copy by one refresh interval.
+             *
+             *      PRESENT ONLY when `accepted` is true. Absent — never zeros — on every
+             *      refused preview (`accepted: false` with a `reject_reason`): validation, an
+             *      unknown market or account, insufficient margin, a maker-risk constraint, a
+             *      MARKET order with nothing fillable inside the band, and the post-match
+             *      maker-risk revalidation, whose match the engine discards. Such previews
+             *      may still carry `estimated_fee`, which is priced independently of risk
+             *      state. Treat absence as unknown, not as "fills at zero".
+             */
+            expectedMatchResult?: components["schemas"]["MatchResult"] | null;
+            /**
+             * @description The touch on the taking side when a MARKET preview ran (best ask for a BUY, best bid for a SELL) — what expectedMatchResult's walk and its actualSlippageBps are measured from. Present only when accepted is true and the preview is a MARKET order; a LIMIT or IOC preview is measured against its own limit price and publishes nothing here.
+             * @example 100.25
+             */
+            referencePrice?: string | null;
         };
         SimulateParentMarginOrderRiskRequest: {
             /** Format: uuid */
@@ -7752,6 +8082,11 @@ export interface components {
             /** @description Required for normal orders; optional and ignored for reduce-only. */
             leverage?: string | null;
             reduceOnly?: boolean | null;
+            /**
+             * Format: int32
+             * @description MARKET only: client slippage tolerance in basis points, 0..1000, the same rule placement enforces — a LIMIT or IOC preview carrying it is rejected. Tightens the previewed walk to the band the real order will run under and never widens it; omit for the placement default.
+             */
+            slippageToleranceBps?: number | null;
         };
         SimulateRiskBucketOrderRiskRequest: {
             /** Format: uuid */
@@ -7773,6 +8108,11 @@ export interface components {
              * @description Deprecated: accepted and ignored. Cross scope is derived from trading (a pair joins the cross bucket when a cross order on it succeeds; after its positions close it stays listed until a later successful cross order on another pair reconciles the bucket), so a cross preview has nothing to declare: it runs against the account's active cross bucket — or the deterministic bucket a first cross order would create — and the previewed pair is in scope by construction. Rejected for ISOLATED, as before. The response's selectedTradingPairIds reports the derived scope (recorded pairs, pairs with open positions in the bucket, and the previewed pair), never this list.
              */
             selectedTradingPairIds?: string[] | null;
+            /**
+             * Format: int32
+             * @description MARKET only: client slippage tolerance in basis points, 0..1000, the same rule placement enforces — a LIMIT or IOC preview carrying it is rejected. Tightens the previewed walk to the band the real order will run under and never widens it; omit for the placement default.
+             */
+            slippageToleranceBps?: number | null;
         };
         SubAccount: {
             /**
@@ -8725,6 +9065,16 @@ export interface components {
              */
             expiresAt?: number | null;
             user?: components["schemas"]["UserInfo"];
+            /**
+             * @description True when this verify created the user row — the wallet's first sign-in to THIS application. Identity is per `(wallet, application)`, so a wallet already registered on another application is still `is_new_user` on its first sign-in to a new one. Use it to gate first-time UX (e.g. showing the optional "have a referral code?" input only to new users) and to confirm a fresh sign-up. False for every returning verify on this application.
+             * @example true
+             */
+            isNewUser?: boolean | null;
+            /**
+             * @description True when a PitPass referral relationship was recorded on this verify: a valid, non-self TraderCode presented on the wallet's first sign-in to THIS application resolved to a known referrer. Scoped like `is_new_user` (per `(wallet, application)`), so a wallet already registered on another application can still see this on its first sign-in to a new one. False for a returning user of this application, an absent or unknown code, or a self-referral. Confirms the referral landed for the signup success screen.
+             * @example true
+             */
+            referralApplied?: boolean | null;
         };
         Withdrawal: {
             /**
@@ -13472,6 +13822,88 @@ export interface operations {
             };
         };
     };
+    get_my_referral_position: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["GetMyReferralPositionResponse"];
+                };
+            };
+            /** @description Authentication required */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Read rate limit exceeded — every authenticated read draws one request from the account's read budget; retry after the interval in details.retryAfter */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    get_my_referral_downline: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["GetMyReferralDownlineResponse"];
+                };
+            };
+            /** @description Authentication required */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Read rate limit exceeded — every authenticated read draws one request from the account's read budget; retry after the interval in details.retryAfter */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
     get_rewards_balance: {
         parameters: {
             query?: never;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@0xmonaco/types",
-	"version": "1.0.60",
+	"version": "1.0.62",
 	"type": "module",
 	"homepage": "https://docs.0xmonaco.com/sdk/typescript",
 	"main": "./dist/index.js",
@@ -16,7 +16,7 @@
 		"lint": "biome lint ."
 	},
 	"dependencies": {
-		"@0xmonaco/contracts": "1.0.60",
+		"@0xmonaco/contracts": "1.0.62",
 		"zod": "^4.1.12"
 	},
 	"peerDependencies": {