@pear-protocol/types 1.5.0 → 1.7.0

package/dist/notification/responses.d.ts

@@ -6,6 +6,10 @@ export declare const NotificationListResponse: z.ZodObject<{
             TAKE_PROFIT_HIT: "TAKE_PROFIT_HIT";
             STOP_LOSS_HIT: "STOP_LOSS_HIT";
             TRIGGER_ORDER_HIT: "TRIGGER_ORDER_HIT";
+            TAKE_PROFIT_FAILED: "TAKE_PROFIT_FAILED";
+            STOP_LOSS_FAILED: "STOP_LOSS_FAILED";
+            TRIGGER_ORDER_FAILED: "TRIGGER_ORDER_FAILED";
+            ATTACHED_TRIGGER_DISCARDED: "ATTACHED_TRIGGER_DISCARDED";
         }>;
         parameters: z.ZodDiscriminatedUnion<[z.ZodObject<{
             type: z.ZodLiteral<"take_profit">;
@@ -18,6 +22,25 @@ export declare const NotificationListResponse: z.ZodObject<{
                 okx: "okx";
                 lighter: "lighter";
             }>;
+            metric: z.ZodOptional<z.ZodEnum<{
+                price: "price";
+                notional: "notional";
+                ratio: "ratio";
+                weighted_ratio: "weighted_ratio";
+                upnl: "upnl";
+                upnl_bps: "upnl_bps";
+                funding_rate: "funding_rate";
+                prediction_market: "prediction_market";
+                btc_dominance: "btc_dominance";
+                ratio_trailing: "ratio_trailing";
+                price_trailing: "price_trailing";
+                weighted_ratio_trailing: "weighted_ratio_trailing";
+                notional_trailing: "notional_trailing";
+                upnl_trailing: "upnl_trailing";
+                upnl_bps_trailing: "upnl_bps_trailing";
+            }>>;
+            level: z.ZodOptional<z.ZodNumber>;
+            reason: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>, z.ZodObject<{
             type: z.ZodLiteral<"stop_loss">;
             triggerId: z.ZodUUID;
@@ -29,6 +52,25 @@ export declare const NotificationListResponse: z.ZodObject<{
                 okx: "okx";
                 lighter: "lighter";
             }>;
+            metric: z.ZodOptional<z.ZodEnum<{
+                price: "price";
+                notional: "notional";
+                ratio: "ratio";
+                weighted_ratio: "weighted_ratio";
+                upnl: "upnl";
+                upnl_bps: "upnl_bps";
+                funding_rate: "funding_rate";
+                prediction_market: "prediction_market";
+                btc_dominance: "btc_dominance";
+                ratio_trailing: "ratio_trailing";
+                price_trailing: "price_trailing";
+                weighted_ratio_trailing: "weighted_ratio_trailing";
+                notional_trailing: "notional_trailing";
+                upnl_trailing: "upnl_trailing";
+                upnl_bps_trailing: "upnl_bps_trailing";
+            }>>;
+            level: z.ZodOptional<z.ZodNumber>;
+            reason: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>, z.ZodObject<{
             type: z.ZodLiteral<"trigger_order">;
             triggerId: z.ZodUUID;
@@ -40,6 +82,25 @@ export declare const NotificationListResponse: z.ZodObject<{
                 okx: "okx";
                 lighter: "lighter";
             }>;
+            metric: z.ZodOptional<z.ZodEnum<{
+                price: "price";
+                notional: "notional";
+                ratio: "ratio";
+                weighted_ratio: "weighted_ratio";
+                upnl: "upnl";
+                upnl_bps: "upnl_bps";
+                funding_rate: "funding_rate";
+                prediction_market: "prediction_market";
+                btc_dominance: "btc_dominance";
+                ratio_trailing: "ratio_trailing";
+                price_trailing: "price_trailing";
+                weighted_ratio_trailing: "weighted_ratio_trailing";
+                notional_trailing: "notional_trailing";
+                upnl_trailing: "upnl_trailing";
+                upnl_bps_trailing: "upnl_bps_trailing";
+            }>>;
+            level: z.ZodOptional<z.ZodNumber>;
+            reason: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>, z.ZodObject<{
             type: z.ZodLiteral<"default_trigger">;
             triggerId: z.ZodUUID;
@@ -50,6 +111,65 @@ export declare const NotificationListResponse: z.ZodObject<{
                 okx: "okx";
                 lighter: "lighter";
             }>;
+            metric: z.ZodOptional<z.ZodEnum<{
+                price: "price";
+                notional: "notional";
+                ratio: "ratio";
+                weighted_ratio: "weighted_ratio";
+                upnl: "upnl";
+                upnl_bps: "upnl_bps";
+                funding_rate: "funding_rate";
+                prediction_market: "prediction_market";
+                btc_dominance: "btc_dominance";
+                ratio_trailing: "ratio_trailing";
+                price_trailing: "price_trailing";
+                weighted_ratio_trailing: "weighted_ratio_trailing";
+                notional_trailing: "notional_trailing";
+                upnl_trailing: "upnl_trailing";
+                upnl_bps_trailing: "upnl_bps_trailing";
+            }>>;
+            level: z.ZodOptional<z.ZodNumber>;
+            reason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"attached_trigger_discarded">;
+            positionId: z.ZodUUID;
+            positionKey: z.ZodString;
+            connector: z.ZodEnum<{
+                hyperliquid: "hyperliquid";
+                binance: "binance";
+                bybit: "bybit";
+                okx: "okx";
+                lighter: "lighter";
+            }>;
+            discarded: z.ZodArray<z.ZodObject<{
+                bracketType: z.ZodEnum<{
+                    STOP_LOSS: "STOP_LOSS";
+                    TAKE_PROFIT: "TAKE_PROFIT";
+                }>;
+                metric: z.ZodEnum<{
+                    price: "price";
+                    notional: "notional";
+                    ratio: "ratio";
+                    weighted_ratio: "weighted_ratio";
+                    upnl: "upnl";
+                    upnl_bps: "upnl_bps";
+                    funding_rate: "funding_rate";
+                    prediction_market: "prediction_market";
+                    btc_dominance: "btc_dominance";
+                    ratio_trailing: "ratio_trailing";
+                    price_trailing: "price_trailing";
+                    weighted_ratio_trailing: "weighted_ratio_trailing";
+                    notional_trailing: "notional_trailing";
+                    upnl_trailing: "upnl_trailing";
+                    upnl_bps_trailing: "upnl_bps_trailing";
+                }>;
+                level: z.ZodOptional<z.ZodNumber>;
+                reason: z.ZodEnum<{
+                    TRIGGER_LIMIT: "TRIGGER_LIMIT";
+                    TRAILING_ALREADY_EXISTS: "TRAILING_ALREADY_EXISTS";
+                }>;
+            }, z.core.$strip>>;
+            activeTriggerLimit: z.ZodNumber;
         }, z.core.$strip>], "type">;
         isRead: z.ZodBoolean;
         createdAt: 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>;