@pear-protocol/types 1.32.0 → 2.0.0

package/dist/position/entities.js

@@ -71,11 +71,11 @@ const Position = z.object({
   createdAt: z.string(),
   updatedAt: z.string()
 });
-const ClosedTradeLegSide = z.enum([
+const ClosedPositionLegSide = z.enum([
   "LONG",
   "SHORT"
 ]);
-const ClosedTradeStepLeg = z.discriminatedUnion("kind", [
+const PositionStepLeg = z.discriminatedUnion("kind", [
   z.object({
     kind: z.literal("INCREASE"),
     asset: InstrumentId,
@@ -119,7 +119,7 @@ const ClosedTradeStepLeg = z.discriminatedUnion("kind", [
     pearFee: SignedDecimalString
   })
 ]);
-const ClosedTradeStep = z.object({
+const PositionStep = z.object({
   /**
   * The execution that placed these fills. Absent when the fills recorded none, in
   * which case the step was grouped by fill time and is best effort.
@@ -129,11 +129,11 @@ const ClosedTradeStep = z.object({
   at: z.string(),
   /** Realized PnL this step booked: the sum of its reductions. "+0" for a pure increase. */
   grossPnl: SignedDecimalString,
-  legs: z.array(ClosedTradeStepLeg)
+  legs: z.array(PositionStepLeg)
 });
-const ClosedTradeLeg = z.object({
+const ClosedPositionLeg = z.object({
   asset: InstrumentId,
-  side: ClosedTradeLegSide,
+  side: ClosedPositionLegSide,
   /** Size-weighted average price the leg opened at. Absent with no priced entry. */
   entryVwap: UnsignedDecimalString.optional(),
   /** Size-weighted average price the leg closed at. Absent when nothing closed at a known price. */
@@ -154,6 +154,11 @@ const ClosedTradeLeg = z.object({
   * wants the leg's all-in result adds the two.
   */
   funding: SignedDecimalString,
+  /**
+  * Peak cash this leg alone had committed at one time — the leg's ROI denominator.
+  * "0" is an omission sentinel, not free entry: a zero-price synthetic opened part of
+  * the leg's basis, so its committed cash is unknowable and no return divides by it.
+  */
   entryNotional: UnsignedDecimalString,
   /**
   * Size closed at a known price. With undeterminedSize this accounts for every unit
@@ -168,9 +173,11 @@ const ClosedTradeLeg = z.object({
   */
   undeterminedSize: UnsignedDecimalString
 });
-const ClosedTrade = z.object({
+const ClosedPosition = z.object({
   positionId: z.uuid(),
   connector: Connector,
+  /** Lifecycle tag naming which history shape this row carries; each endpoint serves one of them. */
+  status: z.literal("CLOSED"),
   /** When the position opened. */
   openedAt: z.string(),
   /** When the position closed. Falls back to the last update for rows that never recorded a close. */
@@ -183,15 +190,20 @@ const ClosedTrade = z.object({
   tradeFees: SignedDecimalString,
   pearFees: SignedDecimalString,
   /**
-  * Funding attributed to the whole trade (signed; negative = net paid).
+  * Funding attributed to the whole position (signed; negative = net paid).
   *
   * Totals every asset the position carried exposure on, which can exceed the sum of
   * the legs: funding follows exposure, and an asset with exposure but no confirmed
-  * fill earns no leg. Summing the legs instead would understate what the trade paid.
+  * fill earns no leg. Summing the legs instead would understate what the position paid.
   *
   * Reported beside netPnl, never folded into it. See the leg field's note.
   */
   totalFunding: SignedDecimalString,
+  /**
+  * Peak cash the whole position had committed at one time — the ROI denominator.
+  * "0" is an omission sentinel, not free entry: a zero-price synthetic opened part of
+  * the basis, so committed cash is unknowable and clients must not divide by it.
+  */
   entryNotional: UnsignedDecimalString,
   /**
   * Proceeds of the priced closes. Understates whenever part of the position closed
@@ -212,7 +224,7 @@ const ClosedTrade = z.object({
   unstableHistoricalData: z.boolean(),
   longAssets: z.array(InstrumentId),
   shortAssets: z.array(InstrumentId),
-  legs: z.array(ClosedTradeLeg),
+  legs: z.array(ClosedPositionLeg),
   /**
   * What happened to the position, oldest first: the open, every add, every reduction
   * and the close. `legs` says how each asset finished; this says how it got there.
@@ -221,7 +233,144 @@ const ClosedTrade = z.object({
   * per recorded action, so a heavily traded position produces a long one. `openedAt`
   * carries the open time that step 1 would otherwise have been the only source of.
   */
-  steps: z.array(ClosedTradeStep).optional()
+  steps: z.array(PositionStep).optional()
+});
+const OpenPositionLeg = z.object({
+  asset: InstrumentId,
+  side: ClosedPositionLegSide,
+  /** Everything the leg has already closed. */
+  realized: z.object({
+    /**
+    * Size closed at a known price so far. With `unpricedQuantity` this accounts for
+    * every unit the leg has closed.
+    */
+    quantity: UnsignedDecimalString,
+    /**
+    * Closed size whose PnL is unpriceable, because it closed against a 0-price
+    * synthetic or against an entry basis that was itself unpriced. It contributes
+    * nothing to `grossPnl` or `exitVwap`.
+    */
+    unpricedQuantity: UnsignedDecimalString,
+    /** Size-weighted average price the leg has reduced at so far. Absent when nothing closed at a known price. */
+    exitVwap: UnsignedDecimalString.optional(),
+    /** PnL booked so far, before fees. */
+    grossPnl: SignedDecimalString,
+    /**
+    * PnL booked so far, after every fee charged to date. Entry fees are charged in
+    * full at entry — including on size that has not closed yet — so this understates
+    * until the leg is flat. Lead with `grossPnl` for a live reading.
+    */
+    netPnl: SignedDecimalString
+  }),
+  /**
+  * What the leg still holds: the inputs to an unrealized figure, never the figure itself.
+  */
+  remaining: z.object({
+    /**
+    * The quantity the leg still holds, signed the way `PositionExposure` signs
+    * exposure: `+6` for a long remainder, `-4` for a short one, so a consumer
+    * never has to recombine with `side` before doing arithmetic. "+0" is a real
+    * answer: a leg can walk to flat while the position it belongs to stays open.
+    */
+    quantity: SignedDecimalString,
+    /**
+    * Weighted-average price that remaining quantity was opened at. Absent when the
+    * leg is flat, and absent when what remains was opened against an unpriceable
+    * basis — `quantity` tells the two absences apart.
+    */
+    entryVwap: UnsignedDecimalString.optional()
+  }),
+  /** Signed: a venue maker rebate makes a fee negative. Charged across the leg's whole life. */
+  totalFees: SignedDecimalString,
+  tradeFees: SignedDecimalString,
+  pearFees: SignedDecimalString,
+  /**
+  * Funding attributed to this leg so far (signed; negative = net paid).
+  *
+  * Reported beside realized.netPnl, never folded into it — the same rule as
+  * ClosedPositionLeg. A caller that wants the leg's all-in result adds the two.
+  *
+  * Best-effort: funding payments carry no position id, so attribution walks
+  * exposure snapshots and under-attributes whenever untracked or external
+  * exposure shared the account. The account-level funding total is authoritative.
+  */
+  funding: SignedDecimalString
+});
+const OpenPosition = z.object({
+  positionId: z.uuid(),
+  connector: Connector,
+  /** Lifecycle tag naming which history shape this row carries; each endpoint serves one of them. */
+  status: z.literal("OPEN"),
+  /** When the position opened — the immutable primary sort key for this history. */
+  openedAt: z.string(),
+  /** The position's last update, independent of the page cursor. */
+  updatedAt: z.string(),
+  origin: PositionOrigin,
+  /**
+  * Realized PnL booked so far, before fees. Qualified because the position is still
+  * live, and revisable while it is — see netCashflow on reconciliation.
+  */
+  realizedGrossPnl: SignedDecimalString,
+  /**
+  * Cash booked so far: realized gross PnL minus every fee charged to date. Not a
+  * settled return on closed quantity — it books every fee charged so far, including
+  * entry fees on still-open size. Fee timing distorts it in two directions while
+  * open: entry fees are charged in full at entry (understates), and a provisional
+  * fill carries no fees yet (overstates). A provisional fill also revises its own
+  * price and quantity when it reconciles, so this and realizedGrossPnl can each
+  * change between two reads of a position that did not trade in between. Equals
+  * /positions/closed's netPnl once the position is flat. Lead with realizedGrossPnl
+  * for a live reading.
+  */
+  netCashflow: SignedDecimalString,
+  totalFees: SignedDecimalString,
+  tradeFees: SignedDecimalString,
+  pearFees: SignedDecimalString,
+  /**
+  * Funding attributed to the position so far (signed; negative = net paid).
+  *
+  * Totals every asset the position carried exposure on, which can exceed the sum
+  * of the legs: funding follows exposure, and an asset with exposure but no fill
+  * earns no leg. Reported beside netCashflow, never folded into it.
+  *
+  * Best-effort: funding payments carry no position id, so attribution walks
+  * exposure snapshots and under-attributes whenever untracked or external
+  * exposure shared the account. The account-level funding total is authoritative.
+  */
+  totalFunding: SignedDecimalString,
+  /**
+  * The exposure expressed in USD at the time the position was opened. It does not
+  * change on adjustments, and is only used for UI purposes — exactly the figure
+  * /positions reports.
+  */
+  initialExposureUSD: PositionInitialExposureUSD,
+  /** Whether any fill on the position was a synthetic bridge fill (gap/gone reconstruction). */
+  hasSyntheticFills: z.boolean(),
+  /**
+  * Whether any fill on the position is still PROVISIONAL — the runtime flag that
+  * this row's economics are still settling, since a UI cannot read a JSDoc caveat.
+  * Independent of hasSyntheticFills: a row can have either, both or neither.
+  */
+  hasProvisionalFills: z.boolean(),
+  /** Whether a backfilled fill made this position's historical metrics unreliable. */
+  unstableHistoricalData: z.boolean(),
+  /**
+  * Every asset the ledger recorded, each carrying its own side.
+  *
+  * Unlike ClosedPosition there is no separate longAssets / shortAssets pair: the two would
+  * restate exactly what the legs already say. They survive on the closed shape because
+  * portfolio analytics keys its pair breakdown on them; nothing keys anything on this
+  * endpoint. A caller wanting the basket sides groups the legs by `side`.
+  */
+  legs: z.array(OpenPositionLeg),
+  /**
+  * What has happened to the position so far, oldest first. The step shape is
+  * status-agnostic — it describes what a fill did, and an open position's history
+  * is made of the same actions — so both histories use PositionStep verbatim.
+  *
+  * Absent unless the request asks for it, because the array is unbounded.
+  */
+  steps: z.array(PositionStep).optional()
 });
 
-export { ClosedTrade, ClosedTradeLeg, ClosedTradeLegSide, ClosedTradeStep, ClosedTradeStepLeg, Position, PositionClosedReason, PositionEntryPrices, PositionExposure, PositionInitialExposureUSD, PositionOrigin, PositionStatus, PositionTotalFundingPayment };
+export { ClosedPosition, ClosedPositionLeg, ClosedPositionLegSide, OpenPosition, OpenPositionLeg, Position, PositionClosedReason, PositionEntryPrices, PositionExposure, PositionInitialExposureUSD, PositionOrigin, PositionStatus, PositionStep, PositionStepLeg, PositionTotalFundingPayment };

package/dist/position/queries.d.ts

@@ -18,7 +18,7 @@ export declare const PositionListParams: z.ZodObject<{
 export type PositionListParamsInput = z.input<typeof PositionListParams>;
 export type PositionListParams = z.output<typeof PositionListParams>;
 /**
- * Closed-trade history page.
+ * Closed-position history page.
  *
  * Ordering is fixed at newest-closed-first, so there is no `orderBy`: one order keeps
  * the cursor and the supporting index single-purpose. The connector comes from the
@@ -29,7 +29,23 @@ export declare const ClosedPositionListParams: z.ZodObject<{
     limit: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<number>>>;
     startDate: z.ZodOptional<z.ZodString>;
     endDate: z.ZodOptional<z.ZodString>;
+    positionId: z.ZodOptional<z.ZodUUID>;
     includeSteps: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodCodec<z.ZodString, z.ZodBoolean>]>>>;
 }, z.core.$strip>;
 export type ClosedPositionListParamsInput = z.input<typeof ClosedPositionListParams>;
 export type ClosedPositionListParams = z.output<typeof ClosedPositionListParams>;
+/**
+ * Open-position history page.
+ *
+ * Cursor-paginated like the closed history, ordered newest-created-first. No date
+ * bounds — an open position has no close time to bound by. The connector comes from
+ * the trade-account guard rather than the query.
+ */
+export declare const OpenPositionListParams: z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<number>>>;
+    positionId: z.ZodOptional<z.ZodUUID>;
+    includeSteps: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodCodec<z.ZodString, z.ZodBoolean>]>>>;
+}, z.core.$strip>;
+export type OpenPositionListParamsInput = z.input<typeof OpenPositionListParams>;
+export type OpenPositionListParams = z.output<typeof OpenPositionListParams>;

package/dist/position/queries.js

@@ -41,7 +41,42 @@ const ClosedPositionListParams = CursorFindParams.extend({
   startDate: z.string().optional(),
   endDate: z.string().optional(),
   /**
-  * Whether to return each trade's `steps` timeline. Off by default because the array
+  * Narrows the page to one closed position. The only scope `includeSteps` may be
+  * asked at — see the refinement below.
+  */
+  positionId: z.uuid().optional(),
+  /**
+  * Whether to return each position's `steps` timeline. Off by default because the array
+  * is unbounded, and a caller listing history rarely needs every recorded action of
+  * every row. `openedAt` is always present, so omitting steps costs no timestamp.
+  *
+  * Accepts a real boolean from an SDK caller and its text form from a query string.
+  * Deliberately not `z.coerce.boolean()`, which reads the string "false" as true and
+  * so cannot be switched off from a URL at all.
+  */
+  includeSteps: z.union([
+    z.boolean(),
+    z.stringbool()
+  ]).optional().default(false)
+}).refine((params) => !params.includeSteps || params.positionId !== void 0, {
+  path: [
+    "includeSteps"
+  ],
+  message: "includeSteps requires positionId"
+});
+const OpenPositionListParams = CursorFindParams.extend({
+  /**
+  * Capped below the shared 2000 because every row drags its fills along — one page
+  * of open positions can pull thousands of fill rows into one response.
+  */
+  limit: z.coerce.number().int().positive().max(200).optional().default(20),
+  /**
+  * Narrows the page to one open position. The only scope `includeSteps` may be
+  * asked at — see the refinement below.
+  */
+  positionId: z.uuid().optional(),
+  /**
+  * Whether to return each position's `steps` timeline. Off by default because the array
   * is unbounded, and a caller listing history rarely needs every recorded action of
   * every row. `openedAt` is always present, so omitting steps costs no timestamp.
   *
@@ -53,6 +88,11 @@ const ClosedPositionListParams = CursorFindParams.extend({
     z.boolean(),
     z.stringbool()
   ]).optional().default(false)
+}).refine((params) => !params.includeSteps || params.positionId !== void 0, {
+  path: [
+    "includeSteps"
+  ],
+  message: "includeSteps requires positionId"
 });
 
-export { ClosedPositionListParams, PositionListParams };
+export { ClosedPositionListParams, OpenPositionListParams, PositionListParams };

package/dist/position/responses.d.ts

@@ -80,9 +80,9 @@ export declare const OpenPositionLiteListResponse: z.ZodObject<{
 export type OpenPositionLite = z.output<typeof OpenPositionLite>;
 export type OpenPositionLiteListResponse = z.output<typeof OpenPositionLiteListResponse>;
 /**
- * A page of closed trades.
+ * A page of closed positions.
  *
- * A page may hold fewer than `limit` trades and still return a `nextCursor`: closed
+ * A page may hold fewer than `limit` positions and still return a `nextCursor`: closed
  * positions with no confirmed fills are skipped during composition, exactly as
  * `/portfolio` skips them. Page until `nextCursor` is absent, never until a page
  * comes back short — stopping early silently truncates history.
@@ -90,7 +90,7 @@ export type OpenPositionLiteListResponse = z.output<typeof OpenPositionLiteListR
 export declare const ClosedPositionListResponse: z.ZodObject<{
     limit: z.ZodNumber;
     nextCursor: z.ZodOptional<z.ZodString>;
-    trades: z.ZodArray<z.ZodObject<{
+    positions: z.ZodArray<z.ZodObject<{
         positionId: z.ZodUUID;
         connector: z.ZodEnum<{
             hyperliquid: "hyperliquid";
@@ -99,6 +99,7 @@ export declare const ClosedPositionListResponse: z.ZodObject<{
             okx: "okx";
             lighter: "lighter";
         }>;
+        status: z.ZodLiteral<"CLOSED">;
         openedAt: z.ZodString;
         closedAt: z.ZodString;
         closedReason: z.ZodOptional<z.ZodEnum<{
@@ -185,3 +186,106 @@ export declare const ClosedPositionListResponse: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type ClosedPositionListResponse = z.output<typeof ClosedPositionListResponse>;
+/**
+ * A page of open positions, newest opened first.
+ *
+ * Every open position on the page yields exactly one row: a position whose fills
+ * are not visible yet (mid-sync, recovery) comes back as an explicit zero-state
+ * row rather than disappearing while `/positions` still lists it. Page until
+ * `nextCursor` is absent, never until a page comes back short.
+ */
+export declare const OpenPositionListResponse: z.ZodObject<{
+    limit: z.ZodNumber;
+    nextCursor: z.ZodOptional<z.ZodString>;
+    positions: z.ZodArray<z.ZodObject<{
+        positionId: z.ZodUUID;
+        connector: z.ZodEnum<{
+            hyperliquid: "hyperliquid";
+            binance: "binance";
+            bybit: "bybit";
+            okx: "okx";
+            lighter: "lighter";
+        }>;
+        status: z.ZodLiteral<"OPEN">;
+        openedAt: z.ZodString;
+        updatedAt: z.ZodString;
+        origin: z.ZodEnum<{
+            PARTIAL: "PARTIAL";
+            PEAR: "PEAR";
+            EXTERNAL: "EXTERNAL";
+        }>;
+        realizedGrossPnl: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+        netCashflow: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+        totalFees: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+        tradeFees: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+        pearFees: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+        totalFunding: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+        initialExposureUSD: z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>>;
+        hasSyntheticFills: z.ZodBoolean;
+        hasProvisionalFills: z.ZodBoolean;
+        unstableHistoricalData: z.ZodBoolean;
+        legs: z.ZodArray<z.ZodObject<{
+            asset: z.ZodString;
+            side: z.ZodEnum<{
+                LONG: "LONG";
+                SHORT: "SHORT";
+            }>;
+            realized: z.ZodObject<{
+                quantity: z.ZodString;
+                unpricedQuantity: z.ZodString;
+                exitVwap: z.ZodOptional<z.ZodString>;
+                grossPnl: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+                netPnl: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+            }, z.core.$strip>;
+            remaining: z.ZodObject<{
+                quantity: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+                entryVwap: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            totalFees: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+            tradeFees: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+            pearFees: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+            funding: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+        }, z.core.$strip>>;
+        steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            executionId: z.ZodOptional<z.ZodString>;
+            at: z.ZodString;
+            grossPnl: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+            legs: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"INCREASE">;
+                asset: z.ZodString;
+                side: z.ZodEnum<{
+                    BUY: "BUY";
+                    SELL: "SELL";
+                }>;
+                quantity: z.ZodString;
+                price: z.ZodString;
+                tradeFee: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+                pearFee: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"REDUCE">;
+                asset: z.ZodString;
+                side: z.ZodEnum<{
+                    BUY: "BUY";
+                    SELL: "SELL";
+                }>;
+                quantity: z.ZodString;
+                price: z.ZodString;
+                entryBasis: z.ZodString;
+                grossPnl: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+                tradeFee: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+                pearFee: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"REDUCE_UNPRICED">;
+                asset: z.ZodString;
+                side: z.ZodEnum<{
+                    BUY: "BUY";
+                    SELL: "SELL";
+                }>;
+                quantity: z.ZodString;
+                tradeFee: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+                pearFee: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+            }, z.core.$strip>], "kind">>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type OpenPositionListResponse = z.output<typeof OpenPositionListResponse>;

package/dist/position/responses.js

@@ -3,7 +3,7 @@ import { CursorResponse } from '../common';
 import { SignedDecimalString } from '../common/schema';
 import { Connector } from '../connector';
 import { InstrumentId } from '../instrument';
-import { Position, PositionOrigin, ClosedTrade } from './entities';
+import { Position, PositionOrigin, ClosedPosition, OpenPosition } from './entities';
 
 const PositionListResponse = CursorResponse.extend({
   positions: z.array(Position)
@@ -21,7 +21,10 @@ const OpenPositionLiteListResponse = z.object({
   positions: z.array(OpenPositionLite)
 });
 const ClosedPositionListResponse = CursorResponse.extend({
-  trades: z.array(ClosedTrade)
+  positions: z.array(ClosedPosition)
+});
+const OpenPositionListResponse = CursorResponse.extend({
+  positions: z.array(OpenPosition)
 });
 
-export { ClosedPositionListResponse, OpenPositionLite, OpenPositionLiteListResponse, PositionListResponse };
+export { ClosedPositionListResponse, OpenPositionListResponse, OpenPositionLite, OpenPositionLiteListResponse, PositionListResponse };

package/dist/statistics/queries.d.ts

@@ -1,12 +1,12 @@
 import { z } from 'zod';
 export declare const VolumeStatisticsQueryParams: z.ZodObject<{
-    connector: z.ZodEnum<{
+    connector: z.ZodOptional<z.ZodEnum<{
         hyperliquid: "hyperliquid";
         binance: "binance";
         bybit: "bybit";
         okx: "okx";
         lighter: "lighter";
-    }>;
+    }>>;
     resolution: z.ZodEnum<{
         "1h": "1h";
         "4h": "4h";
@@ -19,13 +19,13 @@ export declare const VolumeStatisticsQueryParams: z.ZodObject<{
 export type VolumeStatisticsQueryParamsInput = z.input<typeof VolumeStatisticsQueryParams>;
 export type VolumeStatisticsQueryParams = z.output<typeof VolumeStatisticsQueryParams>;
 export declare const OiStatisticsQueryParams: z.ZodObject<{
-    connector: z.ZodEnum<{
+    connector: z.ZodOptional<z.ZodEnum<{
         hyperliquid: "hyperliquid";
         binance: "binance";
         bybit: "bybit";
         okx: "okx";
         lighter: "lighter";
-    }>;
+    }>>;
     resolution: z.ZodEnum<{
         "1h": "1h";
         "4h": "4h";
@@ -38,22 +38,22 @@ export declare const OiStatisticsQueryParams: z.ZodObject<{
 export type OiStatisticsQueryParamsInput = z.input<typeof OiStatisticsQueryParams>;
 export type OiStatisticsQueryParams = z.output<typeof OiStatisticsQueryParams>;
 export declare const StatisticsTotalsQueryParams: z.ZodObject<{
-    connector: z.ZodEnum<{
+    connector: z.ZodOptional<z.ZodEnum<{
         hyperliquid: "hyperliquid";
         binance: "binance";
         bybit: "bybit";
         okx: "okx";
         lighter: "lighter";
-    }>;
+    }>>;
     clientId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type StatisticsTotalsQueryParamsInput = z.input<typeof StatisticsTotalsQueryParams>;
 export type StatisticsTotalsQueryParams = z.output<typeof StatisticsTotalsQueryParams>;
 export declare const LeaderboardSortBy: z.ZodEnum<{
-    trades: "trades";
     volume: "volume";
     totalNetPnl: "totalNetPnl";
     roi: "roi";
+    trades: "trades";
 }>;
 export type LeaderboardSortBy = z.infer<typeof LeaderboardSortBy>;
 export declare const LEADERBOARD_MAX_LIMIT = 200;
@@ -68,10 +68,10 @@ export declare const LeaderboardQueryParams: z.ZodObject<{
     }>>>>;
     asset: z.ZodOptional<z.ZodPipe<z.ZodTransform<string[] | (string[] & any[]) | undefined, string[]>, z.ZodArray<z.ZodString>>>;
     sortBy: z.ZodDefault<z.ZodEnum<{
-        trades: "trades";
         volume: "volume";
         totalNetPnl: "totalNetPnl";
         roi: "roi";
+        trades: "trades";
     }>>;
     startDate: z.ZodOptional<z.ZodPipe<z.ZodCoercedNumber<number>, z.ZodTransform<Date, number>>>;
     endDate: z.ZodOptional<z.ZodPipe<z.ZodCoercedNumber<number>, z.ZodTransform<Date, number>>>;

package/dist/statistics/queries.js

@@ -3,7 +3,7 @@ import { normalizeArray } from '../common/array';
 import { Connector } from '../connector';
 
 const VolumeStatisticsQueryParams = z.object({
-  connector: Connector,
+  connector: Connector.optional(),
   resolution: z.enum([
     "1h",
     "4h",
@@ -18,7 +18,7 @@ const VolumeStatisticsQueryParams = z.object({
   message: "startDate must be before endDate"
 });
 const OiStatisticsQueryParams = z.object({
-  connector: Connector,
+  connector: Connector.optional(),
   resolution: z.enum([
     "1h",
     "4h",
@@ -33,7 +33,7 @@ const OiStatisticsQueryParams = z.object({
   message: "startDate must be before endDate"
 });
 const StatisticsTotalsQueryParams = z.object({
-  connector: Connector,
+  connector: Connector.optional(),
   // Per-client scope; absent serves the global totals. The literal 'other'
   // selects the unattributed (NULL) bucket; an unknown code returns zero totals.
   clientId: z.string().trim().min(1).optional()