@pear-protocol/types 1.24.0 → 1.25.0

package/dist/notification/responses.js

@@ -6,14 +6,14 @@ const NotificationListResponse = z.object({
 });
 const MarkNotificationsReadResponse = z.object({
   /**
-   * How many notifications were flipped from unread to read.
-   */
+  * How many notifications were flipped from unread to read.
+  */
   updated: z.number().int()
 });
 const MarkNotificationUnreadResponse = z.object({
   /**
-   * How many notifications were flipped from read to unread.
-   */
+  * How many notifications were flipped from read to unread.
+  */
   updated: z.number().int()
 });
 

package/dist/order/entities.js

@@ -3,67 +3,75 @@ import { UnsignedDecimalString, Side } from '../common/schema';
 import { Connector } from '../connector';
 import { InstrumentId } from '../instrument';
 
-const OrderStatus = z.enum(["PENDING", "PARTIAL", "FILLED", "CANCELLED", "REJECTED"]);
+const OrderStatus = z.enum([
+  "PENDING",
+  "PARTIAL",
+  "FILLED",
+  "CANCELLED",
+  "REJECTED"
+]);
 const BaseOrder = z.object({
   /**
-   * Order UUID
-   */
+  * Order UUID
+  */
   id: z.uuid(),
   /**
-   * Connector
-   */
+  * Connector
+  */
   connector: Connector,
   /**
-   * Order status
-   */
+  * Order status
+  */
   status: OrderStatus,
   /**
-   * Error message
-   */
+  * Error message
+  */
   error: z.string().optional(),
   /**
-   * Created at timestamp
-   */
+  * Created at timestamp
+  */
   createdAt: z.string(),
   /**
-   * Updated at timestamp
-   */
+  * Updated at timestamp
+  */
   updatedAt: z.string()
 });
 const MarketOrder = BaseOrder.extend({
   /**
-   * Order type
-   */
+  * Order type
+  */
   type: z.literal("MARKET"),
   /**
-   * Instrument ID
-   */
+  * Instrument ID
+  */
   symbol: InstrumentId,
   /**
-   * Side
-   */
+  * Side
+  */
   side: Side,
   /**
-   * Reduce only flag
-   */
+  * Reduce only flag
+  */
   reduceOnly: z.boolean(),
   /**
-   * Contract quantity to trade
-   */
+  * Contract quantity to trade
+  */
   quantity: UnsignedDecimalString,
   /**
-   * Price
-   */
+  * Price
+  */
   price: UnsignedDecimalString,
   /**
-   * Filled contract quantity
-   */
+  * Filled contract quantity
+  */
   filledQuantity: UnsignedDecimalString,
   /**
-   * Filled price
-   */
+  * Filled price
+  */
   filledPrice: UnsignedDecimalString.optional()
 });
-const Order = z.discriminatedUnion("type", [BaseOrder.extend(MarketOrder.shape)]);
+const Order = z.discriminatedUnion("type", [
+  BaseOrder.extend(MarketOrder.shape)
+]);
 
 export { MarketOrder, Order, OrderStatus };

package/dist/portfolio/queries.js

@@ -1,19 +1,34 @@
 import { z } from 'zod';
 
-const PortfolioSource = z.enum(["all", "pear"]);
+const PortfolioSource = z.enum([
+  "all",
+  "pear"
+]);
 const PortfolioQuery = z.object({
   startDate: z.string().optional(),
   endDate: z.string().optional(),
   // "pear" excludes external imported fills from volume calculations.
   source: PortfolioSource.optional().default("all")
 });
-const PortfolioAnalyticsInterval = z.enum(["1d", "1w", "1m", "1y", "all"]);
+const PortfolioAnalyticsInterval = z.enum([
+  "1d",
+  "1w",
+  "1m",
+  "1y",
+  "all"
+]);
 const PortfolioAnalyticsQuery = z.object({
   startDate: z.string().optional(),
   endDate: z.string().optional(),
   interval: PortfolioAnalyticsInterval.optional(),
   rollingWindowDays: z.coerce.number().int().optional(),
-  includeSeries: z.union([z.boolean(), z.enum(["false", "true"]).transform((value) => value === "true")]).optional(),
+  includeSeries: z.union([
+    z.boolean(),
+    z.enum([
+      "false",
+      "true"
+    ]).transform((value) => value === "true")
+  ]).optional(),
   source: PortfolioSource.optional().default("all")
 });
 

package/dist/position/entities.js

@@ -3,69 +3,86 @@ import { SignedDecimalString, UnsignedDecimalString } from '../common/schema';
 import { Connector } from '../connector';
 import { InstrumentId } from '../instrument';
 
-const PositionStatus = z.enum(["OPEN", "CLOSED"]);
-const PositionClosedReason = z.enum(["NETTED", "USER", "LIQUIDATED"]);
-const PositionOrigin = z.enum(["PEAR", "EXTERNAL", "PARTIAL"]);
+const PositionStatus = z.enum([
+  "OPEN",
+  "CLOSED"
+]);
+const PositionClosedReason = z.enum([
+  "NETTED",
+  "USER",
+  "LIQUIDATED"
+]);
+const PositionOrigin = z.enum([
+  "PEAR",
+  "EXTERNAL",
+  "PARTIAL"
+]);
 const PositionExposure = z.record(InstrumentId, SignedDecimalString);
 const PositionInitialExposureUSD = z.record(InstrumentId, SignedDecimalString);
 const PositionTotalFundingPayment = z.record(InstrumentId, SignedDecimalString);
 const PositionEntryPrices = z.record(InstrumentId, UnsignedDecimalString);
 const Position = z.object({
   /**
-   * Position UUID
-   */
+  * Position UUID
+  */
   id: z.uuid(),
   /**
-   * Trade account UUID
-   */
+  * Trade account UUID
+  */
   tradeAccountId: z.uuid(),
   /**
-   * Connector
-   */
+  * Connector
+  */
   connector: Connector,
   /**
-   * Position status
-   */
+  * Position status
+  */
   status: PositionStatus,
   /**
-   * Closed reason
-   */
+  * Closed reason
+  */
   closedReason: PositionClosedReason.nullable().optional(),
   origin: PositionOrigin,
   /**
-   * Position exposure
-   */
+  * Position exposure
+  */
   exposure: PositionExposure,
   /**
-   * Whether a backfilled fill invalidated historical metrics derived from this position.
-   */
+  * Whether a backfilled fill invalidated historical metrics derived from this position.
+  */
   unstableHistoricalData: z.boolean(),
   totalFundingPayment: PositionTotalFundingPayment,
   /**
-   * Closed at timestamp
-   */
+  * Closed at timestamp
+  */
   closedAt: z.string().nullable().optional(),
   /**
-   * 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.
-   */
+  * 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.
+  */
   initialExposureUSD: PositionInitialExposureUSD,
   /**
-   * Per-instrument entry (cost-basis) price, derived from the fills ledger. Unlike
-   * initialExposureUSD, this DOES account for adjustments — it is the live weighted-average
-   * entry price of the current exposure.
-   */
+  * Per-instrument entry (cost-basis) price, derived from the fills ledger. Unlike
+  * initialExposureUSD, this DOES account for adjustments — it is the live weighted-average
+  * entry price of the current exposure.
+  */
   entryPrices: PositionEntryPrices,
   createdAt: z.string(),
   updatedAt: z.string()
 });
-const ClosedTradeLegSide = z.enum(["LONG", "SHORT"]);
+const ClosedTradeLegSide = z.enum([
+  "LONG",
+  "SHORT"
+]);
 const ClosedTradeStepLeg = z.discriminatedUnion("kind", [
   z.object({
     kind: z.literal("INCREASE"),
     asset: InstrumentId,
-    side: z.enum(["BUY", "SELL"]),
+    side: z.enum([
+      "BUY",
+      "SELL"
+    ]),
     quantity: UnsignedDecimalString,
     /** "0" on an unpriceable synthetic — the ledger recorded no price to report. */
     price: UnsignedDecimalString,
@@ -76,7 +93,10 @@ const ClosedTradeStepLeg = z.discriminatedUnion("kind", [
   z.object({
     kind: z.literal("REDUCE"),
     asset: InstrumentId,
-    side: z.enum(["BUY", "SELL"]),
+    side: z.enum([
+      "BUY",
+      "SELL"
+    ]),
     /** The quantity that actually closed. On a flip this is less than the fill's own size. */
     quantity: UnsignedDecimalString,
     price: UnsignedDecimalString,
@@ -90,7 +110,10 @@ const ClosedTradeStepLeg = z.discriminatedUnion("kind", [
   z.object({
     kind: z.literal("REDUCE_UNPRICED"),
     asset: InstrumentId,
-    side: z.enum(["BUY", "SELL"]),
+    side: z.enum([
+      "BUY",
+      "SELL"
+    ]),
     quantity: UnsignedDecimalString,
     tradeFee: SignedDecimalString,
     pearFee: SignedDecimalString
@@ -98,9 +121,9 @@ const ClosedTradeStepLeg = z.discriminatedUnion("kind", [
 ]);
 const ClosedTradeStep = 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.
-   */
+  * 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.
+  */
   executionId: z.string().optional(),
   /** When the step's fills landed. */
   at: z.string(),
@@ -124,25 +147,25 @@ const ClosedTradeLeg = z.object({
   tradeFees: SignedDecimalString,
   pearFees: SignedDecimalString,
   /**
-   * Funding attributed to this leg over the position's life (signed; negative = net paid).
-   *
-   * Reported beside netPnl, never folded into it: netPnl carries the same fills-only
-   * meaning here as in /portfolio, and funding is a separate cash flow. A caller that
-   * wants the leg's all-in result adds the two.
-   */
+  * Funding attributed to this leg over the position's life (signed; negative = net paid).
+  *
+  * Reported beside netPnl, never folded into it: netPnl carries the same fills-only
+  * meaning here as in /portfolio, and funding is a separate cash flow. A caller that
+  * wants the leg's all-in result adds the two.
+  */
   funding: SignedDecimalString,
   entryNotional: UnsignedDecimalString,
   /**
-   * Size closed at a known price. With undeterminedSize this accounts for every unit
-   * the leg closed, so the total closed size is the sum of the two. It is not reported
-   * separately, because a value derivable from two others can only drift.
-   */
+  * Size closed at a known price. With undeterminedSize this accounts for every unit
+  * the leg closed, so the total closed size is the sum of the two. It is not reported
+  * separately, because a value derivable from two others can only drift.
+  */
   exitQuantity: 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.
-   */
+  * 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.
+  */
   undeterminedSize: UnsignedDecimalString
 });
 const ClosedTrade = z.object({
@@ -160,28 +183,28 @@ const ClosedTrade = z.object({
   tradeFees: SignedDecimalString,
   pearFees: SignedDecimalString,
   /**
-   * Funding attributed to the whole trade (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.
-   *
-   * Reported beside netPnl, never folded into it. See the leg field's note.
-   */
+  * Funding attributed to the whole trade (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.
+  *
+  * Reported beside netPnl, never folded into it. See the leg field's note.
+  */
   totalFunding: SignedDecimalString,
   entryNotional: UnsignedDecimalString,
   /**
-   * Proceeds of the priced closes. Understates whenever part of the position closed
-   * unpriceably — exitNotionalComplete says whether that happened.
-   */
+  * Proceeds of the priced closes. Understates whenever part of the position closed
+  * unpriceably — exitNotionalComplete says whether that happened.
+  */
   exitNotional: UnsignedDecimalString,
   /**
-   * True when every closed unit had a known price, so exitNotional is the whole story.
-   *
-   * This is NOT the negation of hasSyntheticFills. A synthetic fill can carry a real
-   * price and stay complete, and a priced closing fill still breaks completeness when
-   * the entry basis it closed against was unpriced.
-   */
+  * True when every closed unit had a known price, so exitNotional is the whole story.
+  *
+  * This is NOT the negation of hasSyntheticFills. A synthetic fill can carry a real
+  * price and stay complete, and a priced closing fill still breaks completeness when
+  * the entry basis it closed against was unpriced.
+  */
   exitNotionalComplete: z.boolean(),
   /** Whether any fill on the position was a synthetic bridge fill (gap/gone reconstruction). */
   hasSyntheticFills: z.boolean(),
@@ -191,13 +214,13 @@ const ClosedTrade = z.object({
   shortAssets: z.array(InstrumentId),
   legs: z.array(ClosedTradeLeg),
   /**
-   * 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.
-   *
-   * Absent unless the request asks for it, because the array is unbounded — one entry
-   * 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.
-   */
+  * 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.
+  *
+  * Absent unless the request asks for it, because the array is unbounded — one entry
+  * 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()
 });
 

package/dist/position/queries.js

@@ -8,45 +8,51 @@ const OrderBy = z.union([
   z.literal("updatedAt"),
   z.literal("-updatedAt")
 ]);
-const StatusEnum = z.enum(["OPEN", "CLOSED"]);
+const StatusEnum = z.enum([
+  "OPEN",
+  "CLOSED"
+]);
 const StatusArray = z.preprocess((arg) => normalizeArray(arg), z.array(StatusEnum));
 const PositionListParams = CursorFindParams.extend({
   /**
-   * Connector filter
-   */
+  * Connector filter
+  */
   connector: Connector.optional(),
   /**
-   * Status filter
-   */
+  * Status filter
+  */
   status: StatusArray.optional(),
   /**
-   * Order by field
-   */
+  * Order by field
+  */
   orderBy: OrderBy.default("-createdAt")
 });
 const ClosedPositionListParams = CursorFindParams.extend({
   /**
-   * Capped below the shared 2000 because every row drags its fills along — 2000
-   * closed positions could pull tens of thousands of fill rows into one response.
-   */
+  * Capped below the shared 2000 because every row drags its fills along — 2000
+  * closed positions could pull tens of thousands of fill rows into one response.
+  */
   limit: z.coerce.number().int().positive().max(200).optional().default(20),
   /**
-   * Inclusive bounds on the close time. They filter the same
-   * `coalesce(closed_at, updated_at)` expression the ordering and cursor use, so
-   * filtering and paging cannot disagree. Absent means unbounded.
-   */
+  * Inclusive bounds on the close time. They filter the same
+  * `coalesce(closed_at, updated_at)` expression the ordering and cursor use, so
+  * filtering and paging cannot disagree. Absent means unbounded.
+  */
   startDate: z.string().optional(),
   endDate: z.string().optional(),
   /**
-   * Whether to return each trade'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)
+  * Whether to return each trade'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)
 });
 
 export { ClosedPositionListParams, PositionListParams };

package/dist/price/entities.js

@@ -1,7 +1,10 @@
 import { z } from 'zod';
 import { InstrumentId } from '../instrument';
 
-const PriceSource = z.enum(["mid", "mark"]);
+const PriceSource = z.enum([
+  "mid",
+  "mark"
+]);
 const InstrumentPriceMap = z.record(InstrumentId, z.string());
 
 export { InstrumentPriceMap, PriceSource };

package/dist/price/responses.js

@@ -3,12 +3,12 @@ import { InstrumentPriceMap } from './entities';
 
 const PricesResponse = z.object({
   /**
-   * Mid prices for instruments
-   */
+  * Mid prices for instruments
+  */
   mid: InstrumentPriceMap,
   /**
-   * Mark prices for instruments
-   */
+  * Mark prices for instruments
+  */
   mark: InstrumentPriceMap
 });
 

package/dist/rebalance/entities.js

@@ -2,16 +2,29 @@ import { z } from 'zod';
 import { UnsignedDecimalString } from '../common/schema';
 import { InstrumentId } from '../instrument';
 
-const AutoRebalanceStatus = z.enum(["ACTIVE", "PAUSED"]);
+const AutoRebalanceStatus = z.enum([
+  "ACTIVE",
+  "PAUSED"
+]);
 const AutoRebalancePausedReason = z.enum([
   "USER",
   "POSITION_CHANGED",
   "REPEATED_FAILURES",
   "INVALID_LIVE_BETA_EXPOSURE"
 ]);
-const AutoRebalanceWeightSource = z.enum(["INITIAL_WEIGHT", "LIVE_BETA"]);
-const AutoRebalanceTimeframe = z.enum(["1h", "4h", "1d"]);
-const RebalanceEventStatus = z.enum(["SUCCESS", "FAILED"]);
+const AutoRebalanceWeightSource = z.enum([
+  "INITIAL_WEIGHT",
+  "LIVE_BETA"
+]);
+const AutoRebalanceTimeframe = z.enum([
+  "1h",
+  "4h",
+  "1d"
+]);
+const RebalanceEventStatus = z.enum([
+  "SUCCESS",
+  "FAILED"
+]);
 const WeightMap = z.record(InstrumentId, z.number());
 const AutoRebalanceConfigBase = z.object({
   id: z.uuid(),
@@ -23,7 +36,9 @@ const AutoRebalanceConfigBase = z.object({
   updatedAt: z.iso.datetime()
 });
 const AutoRebalanceBetaState = z.discriminatedUnion("state", [
-  z.object({ state: z.literal("PENDING") }),
+  z.object({
+    state: z.literal("PENDING")
+  }),
   z.object({
     state: z.literal("BASELINED"),
     // The frozen drift baseline: implied beta of the achieved leg split at entry, re-snapshotted after
@@ -45,7 +60,9 @@ const AutoRebalanceBetaState = z.discriminatedUnion("state", [
   })
 ]);
 const AutoRebalanceConfig = z.discriminatedUnion("weightSource", [
-  AutoRebalanceConfigBase.extend({ weightSource: z.literal("INITIAL_WEIGHT") }),
+  AutoRebalanceConfigBase.extend({
+    weightSource: z.literal("INITIAL_WEIGHT")
+  }),
   AutoRebalanceConfigBase.extend({
     weightSource: z.literal("LIVE_BETA"),
     // Stat-arb bar timeframe selecting which realtime candle feed drives the drift comparison.

package/dist/rebalance/payloads.js

@@ -8,15 +8,17 @@ import { AutoRebalanceTimeframe, AutoRebalanceStatus } from './entities';
 
 const RebalanceManual = z.object({
   orderType: ExecutionOrderType,
-  weightings: z.array(
-    z.object({
-      symbol: InstrumentId,
-      weight: z.number().positive({ message: "Weight must be greater than 0" }).max(1, { message: "Weight must be less than 1" })
+  weightings: z.array(z.object({
+    symbol: InstrumentId,
+    weight: z.number().positive({
+      message: "Weight must be greater than 0"
+    }).max(1, {
+      message: "Weight must be less than 1"
     })
-  ).superRefine(RefineWeightingSum).superRefine(RefineUniqueSymbols).describe("Array of weightings to rebalance the position"),
+  })).superRefine(RefineWeightingSum).superRefine(RefineUniqueSymbols).describe("Array of weightings to rebalance the position"),
   /**
-   * Attribution route code (client_ids.code)
-   */
+  * Attribution route code (client_ids.code)
+  */
   clientId: ClientIdCode
 });
 const MinimumDriftPct = UnsignedDecimalString.refine((value) => Number(value) > 0 && Number(value) <= 1, {
@@ -31,10 +33,20 @@ const LiveBetaConfig = z.object({
   minimumDriftPct: MinimumDriftPct,
   timeframe: AutoRebalanceTimeframe
 });
-const CreateInitialWeight = InitialWeightConfig.extend({ positionId: z.uuid() });
-const CreateLiveBeta = LiveBetaConfig.extend({ positionId: z.uuid() });
-const CreateAutoRebalanceConfig = z.discriminatedUnion("weightSource", [CreateInitialWeight, CreateLiveBeta]);
-const ReplaceAutoRebalanceConfig = z.discriminatedUnion("weightSource", [InitialWeightConfig, LiveBetaConfig]);
+const CreateInitialWeight = InitialWeightConfig.extend({
+  positionId: z.uuid()
+});
+const CreateLiveBeta = LiveBetaConfig.extend({
+  positionId: z.uuid()
+});
+const CreateAutoRebalanceConfig = z.discriminatedUnion("weightSource", [
+  CreateInitialWeight,
+  CreateLiveBeta
+]);
+const ReplaceAutoRebalanceConfig = z.discriminatedUnion("weightSource", [
+  InitialWeightConfig,
+  LiveBetaConfig
+]);
 const UpdateAutoRebalanceConfig = z.object({
   minimumDriftPct: MinimumDriftPct.optional(),
   timeframe: AutoRebalanceTimeframe.optional(),

package/dist/rebalance/queries.js

@@ -2,14 +2,8 @@ import { z } from 'zod';
 import { normalizeArray, CursorFindParams } from '../common';
 import { AutoRebalanceStatus, AutoRebalanceWeightSource } from './entities';
 
-const StatusArray = z.preprocess(
-  (arg) => normalizeArray(arg),
-  z.array(AutoRebalanceStatus)
-);
-const WeightSourceArray = z.preprocess(
-  (arg) => normalizeArray(arg),
-  z.array(AutoRebalanceWeightSource)
-);
+const StatusArray = z.preprocess((arg) => normalizeArray(arg), z.array(AutoRebalanceStatus));
+const WeightSourceArray = z.preprocess((arg) => normalizeArray(arg), z.array(AutoRebalanceWeightSource));
 const AutoRebalanceListParams = CursorFindParams.extend({
   status: StatusArray.optional(),
   weightSource: WeightSourceArray.optional(),