@pear-protocol/types 1.5.0 → 1.6.0

package/dist/fill/entities.d.ts

@@ -30,6 +30,7 @@ export declare const Fill: z.ZodObject<{
     }>;
     reduceOnly: z.ZodBoolean;
     isExternal: z.ZodBoolean;
+    synthetic: z.ZodBoolean;
     quantity: z.ZodString;
     price: z.ZodString;
     usd: z.ZodString;

package/dist/fill/entities.js

@@ -9,13 +9,9 @@ const Fill = z.object({
    * Fill UUID
    */
   id: z.uuid(),
-  /**
-   * Client order ID
-   */
+  /** Client order ID (abbreviated as cloid) */
   cloid: z.string().optional(),
-  /**
-   * Exchange-native fill ID (tradeId / tid / etc)
-   */
+  /** Exchange-native fill ID (tradeId / tid / etc) */
   exchangeFillId: z.string().optional(),
   /**
    * Fill lifecycle status
@@ -45,21 +41,17 @@ const Fill = z.object({
    * Reduce only flag
    */
   reduceOnly: z.boolean(),
-  /**
-   * True when the fill was created from external sync.
-   */
+  /** True when the fill was created from external sync. */
   isExternal: z.boolean(),
   /**
-   * Filled quantity
+   * True when the fill is a synthetic bridge fill (gap/gone reconstruction).
+   * Unpriceable gone-close synthetics carry "0" price/usd and should be displayed distinctly.
    */
+  synthetic: z.boolean(),
   quantity: z.string(),
-  /**
-   * Filled price
-   */
+  /** Filled price — "0" on an unpriceable gone-close synthetic (no price guessing). */
   price: z.string(),
-  /**
-   * USD value
-   */
+  /** USD value — "0" on an unpriceable gone-close synthetic (cannot compute without price). */
   usd: z.string(),
   /**
    * Trade fee paid

package/dist/fill/responses.d.ts

@@ -27,6 +27,7 @@ export declare const FillListResponse: z.ZodObject<{
         }>;
         reduceOnly: z.ZodBoolean;
         isExternal: z.ZodBoolean;
+        synthetic: z.ZodBoolean;
         quantity: z.ZodString;
         price: z.ZodString;
         usd: z.ZodString;
@@ -66,6 +67,7 @@ export declare const PositionFillListResponse: z.ZodObject<{
         }>;
         reduceOnly: z.ZodBoolean;
         isExternal: z.ZodBoolean;
+        synthetic: z.ZodBoolean;
         quantity: z.ZodString;
         price: z.ZodString;
         usd: z.ZodString;

package/dist/ladder/entities.d.ts

@@ -77,6 +77,7 @@ export declare const Ladder: z.ZodObject<{
             }>;
             reduceOnly: z.ZodBoolean;
             isExternal: z.ZodBoolean;
+            synthetic: z.ZodBoolean;
             quantity: z.ZodString;
             price: z.ZodString;
             usd: z.ZodString;
@@ -276,6 +277,7 @@ export declare const Ladder: z.ZodObject<{
             }>;
             reduceOnly: z.ZodBoolean;
             isExternal: z.ZodBoolean;
+            synthetic: z.ZodBoolean;
             quantity: z.ZodString;
             price: z.ZodString;
             usd: z.ZodString;
@@ -521,6 +523,7 @@ export declare const Ladder: z.ZodObject<{
             }>;
             reduceOnly: z.ZodBoolean;
             isExternal: z.ZodBoolean;
+            synthetic: z.ZodBoolean;
             quantity: z.ZodString;
             price: z.ZodString;
             usd: z.ZodString;

package/dist/ladder/responses.d.ts

@@ -72,6 +72,7 @@ export declare const CreateLadderResponse: z.ZodObject<{
                 }>;
                 reduceOnly: z.ZodBoolean;
                 isExternal: z.ZodBoolean;
+                synthetic: z.ZodBoolean;
                 quantity: z.ZodString;
                 price: z.ZodString;
                 usd: z.ZodString;
@@ -271,6 +272,7 @@ export declare const CreateLadderResponse: z.ZodObject<{
                 }>;
                 reduceOnly: z.ZodBoolean;
                 isExternal: z.ZodBoolean;
+                synthetic: z.ZodBoolean;
                 quantity: z.ZodString;
                 price: z.ZodString;
                 usd: z.ZodString;
@@ -516,6 +518,7 @@ export declare const CreateLadderResponse: z.ZodObject<{
                 }>;
                 reduceOnly: z.ZodBoolean;
                 isExternal: z.ZodBoolean;
+                synthetic: z.ZodBoolean;
                 quantity: z.ZodString;
                 price: z.ZodString;
                 usd: z.ZodString;
@@ -823,6 +826,7 @@ export declare const LadderResponse: z.ZodObject<{
                 }>;
                 reduceOnly: z.ZodBoolean;
                 isExternal: z.ZodBoolean;
+                synthetic: z.ZodBoolean;
                 quantity: z.ZodString;
                 price: z.ZodString;
                 usd: z.ZodString;
@@ -1022,6 +1026,7 @@ export declare const LadderResponse: z.ZodObject<{
                 }>;
                 reduceOnly: z.ZodBoolean;
                 isExternal: z.ZodBoolean;
+                synthetic: z.ZodBoolean;
                 quantity: z.ZodString;
                 price: z.ZodString;
                 usd: z.ZodString;
@@ -1267,6 +1272,7 @@ export declare const LadderResponse: z.ZodObject<{
                 }>;
                 reduceOnly: z.ZodBoolean;
                 isExternal: z.ZodBoolean;
+                synthetic: z.ZodBoolean;
                 quantity: z.ZodString;
                 price: z.ZodString;
                 usd: z.ZodString;
@@ -1576,6 +1582,7 @@ export declare const LadderListResponse: z.ZodObject<{
                 }>;
                 reduceOnly: z.ZodBoolean;
                 isExternal: z.ZodBoolean;
+                synthetic: z.ZodBoolean;
                 quantity: z.ZodString;
                 price: z.ZodString;
                 usd: z.ZodString;
@@ -1775,6 +1782,7 @@ export declare const LadderListResponse: z.ZodObject<{
                 }>;
                 reduceOnly: z.ZodBoolean;
                 isExternal: z.ZodBoolean;
+                synthetic: z.ZodBoolean;
                 quantity: z.ZodString;
                 price: z.ZodString;
                 usd: z.ZodString;
@@ -2020,6 +2028,7 @@ export declare const LadderListResponse: z.ZodObject<{
                 }>;
                 reduceOnly: z.ZodBoolean;
                 isExternal: z.ZodBoolean;
+                synthetic: z.ZodBoolean;
                 quantity: z.ZodString;
                 price: z.ZodString;
                 usd: z.ZodString;

package/dist/position/entities.d.ts

@@ -10,6 +10,18 @@ export declare const PositionClosedReason: z.ZodEnum<{
     LIQUIDATED: "LIQUIDATED";
 }>;
 export type PositionClosedReason = z.infer<typeof PositionClosedReason>;
+/**
+ * Provenance of a position, derived from the SET of fill origins on it.
+ * - PEAR: opened via Pear, only Pear fills
+ * - EXTERNAL: opened directly on the exchange, only external fills
+ * - PARTIAL: a mix of Pear and external fills
+ */
+export declare const PositionOrigin: z.ZodEnum<{
+    PARTIAL: "PARTIAL";
+    PEAR: "PEAR";
+    EXTERNAL: "EXTERNAL";
+}>;
+export type PositionOrigin = z.infer<typeof PositionOrigin>;
 /**
  * The exposure of a position in directional units for each asset.
  *
@@ -26,6 +38,17 @@ export type PositionExposure = z.infer<typeof PositionExposure>;
  */
 export declare const PositionInitialExposureUSD: z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>>;
 export type PositionInitialExposureUSD = z.infer<typeof PositionInitialExposureUSD>;
+/**
+ * Cumulative funding attributed to this position per asset, in USD (signed;
+ * negative = net paid). Derived by walking the position's exposure snapshots and
+ * summing each in-window funding event as `exposure × fundingPerUnit`. Across a
+ * fully-tracked account the per-position shares sum to the account funding (up to
+ * 20-dp rounding of the coefficient).
+ *
+ * @example { '0': '-1.25' } means 1.25 USD of BTC funding paid over the position's life
+ */
+export declare const PositionTotalFundingPayment: z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>>;
+export type PositionTotalFundingPayment = z.infer<typeof PositionTotalFundingPayment>;
 export declare const Position: z.ZodObject<{
     id: z.ZodUUID;
     tradeAccountId: z.ZodUUID;
@@ -45,7 +68,13 @@ export declare const Position: z.ZodObject<{
         USER: "USER";
         LIQUIDATED: "LIQUIDATED";
     }>>>;
+    origin: z.ZodEnum<{
+        PARTIAL: "PARTIAL";
+        PEAR: "PEAR";
+        EXTERNAL: "EXTERNAL";
+    }>;
     exposure: z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>>;
+    totalFundingPayment: z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>>;
     closedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     initialExposureUSD: z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>>;
     createdAt: z.ZodString;

package/dist/position/entities.js

@@ -5,8 +5,10 @@ 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 PositionExposure = z.record(InstrumentId, SignedDecimalString);
 const PositionInitialExposureUSD = z.record(InstrumentId, SignedDecimalString);
+const PositionTotalFundingPayment = z.record(InstrumentId, SignedDecimalString);
 const Position = z.object({
   /**
    * Position UUID
@@ -28,10 +30,12 @@ const Position = z.object({
    * Closed reason
    */
   closedReason: PositionClosedReason.nullable().optional(),
+  origin: PositionOrigin,
   /**
    * Position exposure
    */
   exposure: PositionExposure,
+  totalFundingPayment: PositionTotalFundingPayment,
   /**
    * Closed at timestamp
    */
@@ -42,14 +46,8 @@ const Position = z.object({
    * on adjustments, and is only used for UI purposes.
    */
   initialExposureUSD: PositionInitialExposureUSD,
-  /**
-   * Created at timestamp
-   */
   createdAt: z.string(),
-  /**
-   * Updated at timestamp
-   */
   updatedAt: z.string()
 });
 
-export { Position, PositionClosedReason, PositionExposure, PositionInitialExposureUSD, PositionStatus };
+export { Position, PositionClosedReason, PositionExposure, PositionInitialExposureUSD, PositionOrigin, PositionStatus, PositionTotalFundingPayment };

package/dist/position/responses.d.ts

@@ -19,7 +19,13 @@ export declare const PositionListResponse: z.ZodObject<{
             USER: "USER";
             LIQUIDATED: "LIQUIDATED";
         }>>>;
+        origin: z.ZodEnum<{
+            PARTIAL: "PARTIAL";
+            PEAR: "PEAR";
+            EXTERNAL: "EXTERNAL";
+        }>;
         exposure: z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>>;
+        totalFundingPayment: z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>>;
         closedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         initialExposureUSD: z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>>;
         createdAt: z.ZodString;
@@ -30,8 +36,13 @@ export type PositionListResponse = z.output<typeof PositionListResponse>;
 export declare const OpenPositionLite: z.ZodObject<{
     id: z.ZodUUID;
     createdAt: z.ZodISODateTime;
-    exposure: z.ZodRecord<z.ZodString, z.ZodString>;
+    exposure: z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>>;
     status: z.ZodLiteral<"OPEN">;
+    origin: z.ZodEnum<{
+        PARTIAL: "PARTIAL";
+        PEAR: "PEAR";
+        EXTERNAL: "EXTERNAL";
+    }>;
     connector: z.ZodEnum<{
         hyperliquid: "hyperliquid";
         binance: "binance";
@@ -44,8 +55,13 @@ export declare const OpenPositionLiteListResponse: z.ZodObject<{
     positions: z.ZodArray<z.ZodObject<{
         id: z.ZodUUID;
         createdAt: z.ZodISODateTime;
-        exposure: z.ZodRecord<z.ZodString, z.ZodString>;
+        exposure: z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>>;
         status: z.ZodLiteral<"OPEN">;
+        origin: z.ZodEnum<{
+            PARTIAL: "PARTIAL";
+            PEAR: "PEAR";
+            EXTERNAL: "EXTERNAL";
+        }>;
         connector: z.ZodEnum<{
             hyperliquid: "hyperliquid";
             binance: "binance";

package/dist/position/responses.js

@@ -1,7 +1,8 @@
 import { z } from 'zod';
+import { SignedDecimalString } from '../common/schema';
 import { Connector } from '../connector';
 import { InstrumentId } from '../instrument';
-import { Position } from './entities';
+import { Position, PositionOrigin } from './entities';
 
 const PositionListResponse = z.object({
   positions: z.array(Position)
@@ -9,8 +10,9 @@ const PositionListResponse = z.object({
 const OpenPositionLite = z.object({
   id: z.uuid(),
   createdAt: z.iso.datetime(),
-  exposure: z.record(InstrumentId, z.string()),
+  exposure: z.record(InstrumentId, SignedDecimalString),
   status: z.literal("OPEN"),
+  origin: PositionOrigin,
   connector: Connector
 });
 const OpenPositionLiteListResponse = z.object({

package/dist/rebalance/entities.d.ts

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+export declare const AutoRebalanceStatus: z.ZodEnum<{
+    ACTIVE: "ACTIVE";
+    PAUSED: "PAUSED";
+}>;
+export type AutoRebalanceStatus = z.infer<typeof AutoRebalanceStatus>;
+export declare const AutoRebalanceWeightSource: z.ZodEnum<{
+    INITIAL_WEIGHT: "INITIAL_WEIGHT";
+    LIVE_BETA: "LIVE_BETA";
+}>;
+export type AutoRebalanceWeightSource = z.infer<typeof AutoRebalanceWeightSource>;
+export declare const AutoRebalanceTimeframe: z.ZodEnum<{
+    "1d": "1d";
+    "1h": "1h";
+    "4h": "4h";
+}>;
+export type AutoRebalanceTimeframe = z.infer<typeof AutoRebalanceTimeframe>;
+export declare const RebalanceEventStatus: z.ZodEnum<{
+    FAILED: "FAILED";
+    SUCCESS: "SUCCESS";
+}>;
+export type RebalanceEventStatus = z.infer<typeof RebalanceEventStatus>;
+export declare const WeightMap: z.ZodRecord<z.ZodString, z.ZodNumber>;
+export type WeightMap = z.output<typeof WeightMap>;
+export declare const AutoRebalanceConfig: z.ZodObject<{
+    id: z.ZodUUID;
+    positionId: z.ZodUUID;
+    status: z.ZodEnum<{
+        ACTIVE: "ACTIVE";
+        PAUSED: "PAUSED";
+    }>;
+    weightSource: z.ZodEnum<{
+        INITIAL_WEIGHT: "INITIAL_WEIGHT";
+        LIVE_BETA: "LIVE_BETA";
+    }>;
+    minimumDriftPct: z.ZodString;
+    timeframe: z.ZodOptional<z.ZodEnum<{
+        "1d": "1d";
+        "1h": "1h";
+        "4h": "4h";
+    }>>;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strip>;
+export type AutoRebalanceConfig = z.output<typeof AutoRebalanceConfig>;
+export declare const RebalanceEvent: z.ZodObject<{
+    id: z.ZodUUID;
+    autoRebalanceConfigId: z.ZodUUID;
+    positionId: z.ZodUUID;
+    weightSource: z.ZodEnum<{
+        INITIAL_WEIGHT: "INITIAL_WEIGHT";
+        LIVE_BETA: "LIVE_BETA";
+    }>;
+    driftPct: z.ZodString;
+    currentWeights: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    targetWeights: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    status: z.ZodEnum<{
+        FAILED: "FAILED";
+        SUCCESS: "SUCCESS";
+    }>;
+    error: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodISODateTime;
+}, z.core.$strip>;
+export type RebalanceEvent = z.output<typeof RebalanceEvent>;

package/dist/rebalance/entities.js

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import { UnsignedDecimalString } from '../common/schema';
+import { InstrumentId } from '../instrument';
+
+const AutoRebalanceStatus = z.enum(["ACTIVE", "PAUSED"]);
+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 AutoRebalanceConfig = z.object({
+  id: z.uuid(),
+  positionId: z.uuid(),
+  status: AutoRebalanceStatus,
+  weightSource: AutoRebalanceWeightSource,
+  minimumDriftPct: UnsignedDecimalString,
+  timeframe: AutoRebalanceTimeframe.optional(),
+  createdAt: z.iso.datetime(),
+  updatedAt: z.iso.datetime()
+});
+const RebalanceEvent = z.object({
+  id: z.uuid(),
+  autoRebalanceConfigId: z.uuid(),
+  positionId: z.uuid(),
+  weightSource: AutoRebalanceWeightSource,
+  driftPct: UnsignedDecimalString,
+  currentWeights: WeightMap,
+  targetWeights: WeightMap,
+  status: RebalanceEventStatus,
+  error: z.string().optional(),
+  createdAt: z.iso.datetime()
+});
+
+export { AutoRebalanceConfig, AutoRebalanceStatus, AutoRebalanceTimeframe, AutoRebalanceWeightSource, RebalanceEvent, RebalanceEventStatus, WeightMap };

package/dist/rebalance/index.d.ts

@@ -1,2 +1,4 @@
+export * from './entities';
 export * from './payloads';
+export * from './queries';
 export * from './responses';

package/dist/rebalance/index.js

@@ -1,2 +1,4 @@
+export * from './entities';
 export * from './payloads';
+export * from './queries';
 export * from './responses';

package/dist/rebalance/payloads.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-export declare const RebalanceManually: z.ZodObject<{
+export declare const RebalanceManual: z.ZodObject<{
     orderType: z.ZodEnum<{
         MARKET: "MARKET";
     }>;
@@ -9,4 +9,50 @@ export declare const RebalanceManually: z.ZodObject<{
     }, z.core.$strip>>;
     clientId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
-export type RebalanceManually = z.output<typeof RebalanceManually>;
+export type RebalanceManual = z.output<typeof RebalanceManual>;
+declare const CreateInitialWeight: z.ZodObject<{
+    weightSource: z.ZodLiteral<"INITIAL_WEIGHT">;
+    positionId: z.ZodUUID;
+    minimumDriftPct: z.ZodString;
+}, z.core.$strip>;
+declare const CreateLiveBeta: z.ZodObject<{
+    weightSource: z.ZodLiteral<"LIVE_BETA">;
+    positionId: z.ZodUUID;
+    minimumDriftPct: z.ZodString;
+    timeframe: z.ZodEnum<{
+        "1d": "1d";
+        "1h": "1h";
+        "4h": "4h";
+    }>;
+}, z.core.$strip>;
+export declare const CreateAutoRebalanceConfig: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    weightSource: z.ZodLiteral<"INITIAL_WEIGHT">;
+    positionId: z.ZodUUID;
+    minimumDriftPct: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    weightSource: z.ZodLiteral<"LIVE_BETA">;
+    positionId: z.ZodUUID;
+    minimumDriftPct: z.ZodString;
+    timeframe: z.ZodEnum<{
+        "1d": "1d";
+        "1h": "1h";
+        "4h": "4h";
+    }>;
+}, z.core.$strip>], "weightSource">;
+export declare const UpdateAutoRebalanceConfig: z.ZodObject<{
+    minimumDriftPct: z.ZodOptional<z.ZodString>;
+    timeframe: z.ZodOptional<z.ZodEnum<{
+        "1d": "1d";
+        "1h": "1h";
+        "4h": "4h";
+    }>>;
+    status: z.ZodOptional<z.ZodEnum<{
+        ACTIVE: "ACTIVE";
+        PAUSED: "PAUSED";
+    }>>;
+}, z.core.$strip>;
+export type CreateInitialWeight = z.output<typeof CreateInitialWeight>;
+export type CreateLiveBeta = z.output<typeof CreateLiveBeta>;
+export type CreateAutoRebalanceConfig = z.output<typeof CreateAutoRebalanceConfig>;
+export type UpdateAutoRebalanceConfig = z.output<typeof UpdateAutoRebalanceConfig>;
+export {};

package/dist/rebalance/payloads.js

@@ -1,10 +1,12 @@
 import { z } from 'zod';
 import { ClientIdCode } from '../common/client-id';
 import { RefineWeightingSum, RefineUniqueSymbols } from '../common/refinement';
+import { UnsignedDecimalString } from '../common/schema';
 import { ExecutionOrderType } from '../execution';
 import { InstrumentId } from '../instrument';
+import { AutoRebalanceTimeframe, AutoRebalanceStatus } from './entities';
 
-const RebalanceManually = z.object({
+const RebalanceManual = z.object({
   orderType: ExecutionOrderType,
   weightings: z.array(
     z.object({
@@ -17,5 +19,25 @@ const RebalanceManually = z.object({
    */
   clientId: ClientIdCode
 });
+const MinimumDriftPct = UnsignedDecimalString.refine((value) => Number(value) > 0 && Number(value) <= 1, {
+  message: "minimumDriftPct must be greater than 0 and at most 1"
+});
+const CreateInitialWeight = z.object({
+  weightSource: z.literal("INITIAL_WEIGHT"),
+  positionId: z.uuid(),
+  minimumDriftPct: MinimumDriftPct
+});
+const CreateLiveBeta = z.object({
+  weightSource: z.literal("LIVE_BETA"),
+  positionId: z.uuid(),
+  minimumDriftPct: MinimumDriftPct,
+  timeframe: AutoRebalanceTimeframe
+});
+const CreateAutoRebalanceConfig = z.discriminatedUnion("weightSource", [CreateInitialWeight, CreateLiveBeta]);
+const UpdateAutoRebalanceConfig = z.object({
+  minimumDriftPct: MinimumDriftPct.optional(),
+  timeframe: AutoRebalanceTimeframe.optional(),
+  status: AutoRebalanceStatus.optional()
+});
 
-export { RebalanceManually };
+export { CreateAutoRebalanceConfig, RebalanceManual, UpdateAutoRebalanceConfig };

package/dist/rebalance/queries.d.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+export declare const AutoRebalanceListParams: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<number>>>;
+    cursor: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodPipe<z.ZodTransform<string[] | (("ACTIVE" | "PAUSED")[] & any[]) | undefined, ("ACTIVE" | "PAUSED")[]>, z.ZodArray<z.ZodEnum<{
+        ACTIVE: "ACTIVE";
+        PAUSED: "PAUSED";
+    }>>>>;
+    weightSource: z.ZodOptional<z.ZodPipe<z.ZodTransform<string[] | (("INITIAL_WEIGHT" | "LIVE_BETA")[] & any[]) | undefined, ("INITIAL_WEIGHT" | "LIVE_BETA")[]>, z.ZodArray<z.ZodEnum<{
+        INITIAL_WEIGHT: "INITIAL_WEIGHT";
+        LIVE_BETA: "LIVE_BETA";
+    }>>>>;
+    positionId: z.ZodOptional<z.ZodUUID>;
+}, z.core.$strip>;
+export type AutoRebalanceListParamsInput = z.input<typeof AutoRebalanceListParams>;
+export type AutoRebalanceListParams = z.output<typeof AutoRebalanceListParams>;
+export declare const RebalanceEventListParams: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<number>>>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type RebalanceEventListParamsInput = z.input<typeof RebalanceEventListParams>;
+export type RebalanceEventListParams = z.output<typeof RebalanceEventListParams>;

package/dist/rebalance/queries.js

@@ -0,0 +1,20 @@
+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 AutoRebalanceListParams = CursorFindParams.extend({
+  status: StatusArray.optional(),
+  weightSource: WeightSourceArray.optional(),
+  positionId: z.uuid().optional()
+});
+const RebalanceEventListParams = CursorFindParams.extend({});
+
+export { AutoRebalanceListParams, RebalanceEventListParams };

package/dist/rebalance/responses.d.ts

@@ -1,10 +1,87 @@
 import { z } from 'zod';
-export declare const RebalanceManuallyResponse: z.ZodObject<{
-    plan: z.ZodUnion<readonly [z.ZodObject<{
+export declare const RebalanceManualResponse: z.ZodObject<{
+    plan: z.ZodDiscriminatedUnion<[z.ZodObject<{
         outcome: z.ZodLiteral<"full_rebalance">;
     }, z.core.$strip>, z.ZodObject<{
-        outcome: z.ZodUnion<readonly [z.ZodLiteral<"partial_rebalance">, z.ZodLiteral<"no_rebalance">]>;
+        outcome: z.ZodLiteral<"partial_rebalance">;
         messages: z.ZodTuple<[z.ZodString], z.ZodString>;
-    }, z.core.$strip>]>;
+    }, z.core.$strip>, z.ZodObject<{
+        outcome: z.ZodLiteral<"no_rebalance">;
+        messages: z.ZodTuple<[z.ZodString], z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        outcome: z.ZodLiteral<"failed">;
+        messages: z.ZodTuple<[z.ZodString], z.ZodString>;
+    }, z.core.$strip>], "outcome">;
+}, z.core.$strip>;
+export type RebalanceManualResponse = z.output<typeof RebalanceManualResponse>;
+export declare const AutoRebalanceListResponse: z.ZodObject<{
+    limit: z.ZodNumber;
+    nextCursor: z.ZodUnion<[z.ZodString, z.ZodUndefined]>;
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodUUID;
+        positionId: z.ZodUUID;
+        status: z.ZodEnum<{
+            ACTIVE: "ACTIVE";
+            PAUSED: "PAUSED";
+        }>;
+        weightSource: z.ZodEnum<{
+            INITIAL_WEIGHT: "INITIAL_WEIGHT";
+            LIVE_BETA: "LIVE_BETA";
+        }>;
+        minimumDriftPct: z.ZodString;
+        timeframe: z.ZodOptional<z.ZodEnum<{
+            "1d": "1d";
+            "1h": "1h";
+            "4h": "4h";
+        }>>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AutoRebalanceListResponse = z.output<typeof AutoRebalanceListResponse>;
+export declare const CreateAutoRebalanceResponse: z.ZodObject<{
+    config: z.ZodObject<{
+        id: z.ZodUUID;
+        positionId: z.ZodUUID;
+        status: z.ZodEnum<{
+            ACTIVE: "ACTIVE";
+            PAUSED: "PAUSED";
+        }>;
+        weightSource: z.ZodEnum<{
+            INITIAL_WEIGHT: "INITIAL_WEIGHT";
+            LIVE_BETA: "LIVE_BETA";
+        }>;
+        minimumDriftPct: z.ZodString;
+        timeframe: z.ZodOptional<z.ZodEnum<{
+            "1d": "1d";
+            "1h": "1h";
+            "4h": "4h";
+        }>>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type CreateAutoRebalanceResponse = z.output<typeof CreateAutoRebalanceResponse>;
+export declare const RebalanceEventListResponse: z.ZodObject<{
+    limit: z.ZodNumber;
+    nextCursor: z.ZodUnion<[z.ZodString, z.ZodUndefined]>;
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodUUID;
+        autoRebalanceConfigId: z.ZodUUID;
+        positionId: z.ZodUUID;
+        weightSource: z.ZodEnum<{
+            INITIAL_WEIGHT: "INITIAL_WEIGHT";
+            LIVE_BETA: "LIVE_BETA";
+        }>;
+        driftPct: z.ZodString;
+        currentWeights: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        targetWeights: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        status: z.ZodEnum<{
+            FAILED: "FAILED";
+            SUCCESS: "SUCCESS";
+        }>;
+        error: z.ZodOptional<z.ZodString>;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
-export type RebalanceManuallyResponse = z.output<typeof RebalanceManuallyResponse>;
+export type RebalanceEventListResponse = z.output<typeof RebalanceEventListResponse>;