@pear-protocol/types 1.5.0 → 1.7.0

package/dist/rebalance/responses.js

@@ -1,15 +1,33 @@
 import { z } from 'zod';
+import { CursorResponse } from '../common';
+import { AutoRebalanceConfig, RebalanceEvent } from './entities';
 
-const RebalanceManuallyResponse = z.object({
-  plan: z.union([
+const RebalanceManualResponse = z.object({
+  plan: z.discriminatedUnion("outcome", [
     z.object({
       outcome: z.literal("full_rebalance")
     }),
     z.object({
-      outcome: z.union([z.literal("partial_rebalance"), z.literal("no_rebalance")]),
+      outcome: z.literal("partial_rebalance"),
+      messages: z.tuple([z.string()]).rest(z.string())
+    }),
+    z.object({
+      outcome: z.literal("no_rebalance"),
+      messages: z.tuple([z.string()]).rest(z.string())
+    }),
+    // `failed` only occurs on background runs (dispatch/cron); MANUAL execution errors throw and surface as HTTP errors instead.
+    z.object({
+      outcome: z.literal("failed"),
       messages: z.tuple([z.string()]).rest(z.string())
     })
   ])
 });
+const AutoRebalanceListResponse = CursorResponse.extend({
+  items: z.array(AutoRebalanceConfig)
+});
+const CreateAutoRebalanceResponse = z.object({ config: AutoRebalanceConfig });
+const RebalanceEventListResponse = CursorResponse.extend({
+  items: z.array(RebalanceEvent)
+});
 
-export { RebalanceManuallyResponse };
+export { AutoRebalanceListResponse, CreateAutoRebalanceResponse, RebalanceEventListResponse, RebalanceManualResponse };

package/dist/schedule/entities.d.ts

@@ -114,6 +114,7 @@ declare const BaseSchedule: z.ZodObject<{
         }>;
         reduceOnly: z.ZodBoolean;
         isExternal: z.ZodBoolean;
+        synthetic: z.ZodBoolean;
         quantity: z.ZodString;
         price: z.ZodString;
         usd: z.ZodString;
@@ -183,6 +184,7 @@ export declare const TWAPOpen: z.ZodObject<{
         }>;
         reduceOnly: z.ZodBoolean;
         isExternal: z.ZodBoolean;
+        synthetic: z.ZodBoolean;
         quantity: z.ZodString;
         price: z.ZodString;
         usd: z.ZodString;
@@ -269,6 +271,7 @@ export declare const TWAPClose: z.ZodObject<{
         }>;
         reduceOnly: z.ZodBoolean;
         isExternal: z.ZodBoolean;
+        synthetic: z.ZodBoolean;
         quantity: z.ZodString;
         price: z.ZodString;
         usd: z.ZodString;
@@ -347,6 +350,7 @@ export declare const Schedule: z.ZodDiscriminatedUnion<[z.ZodObject<{
         }>;
         reduceOnly: z.ZodBoolean;
         isExternal: z.ZodBoolean;
+        synthetic: z.ZodBoolean;
         quantity: z.ZodString;
         price: z.ZodString;
         usd: z.ZodString;
@@ -432,6 +436,7 @@ export declare const Schedule: z.ZodDiscriminatedUnion<[z.ZodObject<{
         }>;
         reduceOnly: z.ZodBoolean;
         isExternal: z.ZodBoolean;
+        synthetic: z.ZodBoolean;
         quantity: z.ZodString;
         price: z.ZodString;
         usd: z.ZodString;

package/dist/schedule/responses.d.ts

@@ -59,6 +59,7 @@ export declare const ScheduleListResponse: z.ZodObject<{
             }>;
             reduceOnly: z.ZodBoolean;
             isExternal: z.ZodBoolean;
+            synthetic: z.ZodBoolean;
             quantity: z.ZodString;
             price: z.ZodString;
             usd: z.ZodString;
@@ -144,6 +145,7 @@ export declare const ScheduleListResponse: z.ZodObject<{
             }>;
             reduceOnly: z.ZodBoolean;
             isExternal: z.ZodBoolean;
+            synthetic: z.ZodBoolean;
             quantity: z.ZodString;
             price: z.ZodString;
             usd: z.ZodString;
@@ -225,6 +227,7 @@ export declare const CreateScheduleResponse: z.ZodObject<{
             }>;
             reduceOnly: z.ZodBoolean;
             isExternal: z.ZodBoolean;
+            synthetic: z.ZodBoolean;
             quantity: z.ZodString;
             price: z.ZodString;
             usd: z.ZodString;
@@ -310,6 +313,7 @@ export declare const CreateScheduleResponse: z.ZodObject<{
             }>;
             reduceOnly: z.ZodBoolean;
             isExternal: z.ZodBoolean;
+            synthetic: z.ZodBoolean;
             quantity: z.ZodString;
             price: z.ZodString;
             usd: z.ZodString;

package/dist/sync/payloads.d.ts

@@ -67,36 +67,6 @@ export declare const ReconcileReplacementExternalFill: z.ZodObject<{
         mark: z.ZodString;
     }, z.core.$strip>>;
 }, z.core.$strip>;
-export declare const CreatableExternalFill: z.ZodObject<{
-    type: z.ZodLiteral<"create">;
-    exchangeFillId: z.ZodString;
-    cloid: z.ZodNullable<z.ZodString>;
-    positionId: z.ZodUUID;
-    connector: z.ZodEnum<{
-        hyperliquid: "hyperliquid";
-        binance: "binance";
-        bybit: "bybit";
-        okx: "okx";
-        lighter: "lighter";
-    }>;
-    symbol: z.ZodString;
-    price: z.ZodString;
-    quantity: z.ZodString;
-    side: z.ZodEnum<{
-        BUY: "BUY";
-        SELL: "SELL";
-    }>;
-    reduceOnly: z.ZodBoolean;
-    timestamp: z.ZodNumber;
-    tradeFee: z.ZodString;
-    liquidation: z.ZodNullable<z.ZodObject<{
-        mark: z.ZodString;
-    }, z.core.$strip>>;
-    original: z.ZodOptional<z.ZodObject<{
-        exchangeFillId: z.ZodString;
-        quantity: z.ZodString;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
 export declare const ConfirmFillsRequest: z.ZodRecord<z.ZodUUID, z.ZodTuple<[z.ZodObject<{
     type: z.ZodLiteral<"confirm">;
     exchangeFillId: z.ZodString;
@@ -205,11 +175,43 @@ export declare const ReconcileFillsRequest: z.ZodRecord<z.ZodString, z.ZodTuple<
         mark: z.ZodString;
     }, z.core.$strip>>;
 }, z.core.$strip>>>;
-export declare const CreateFillsRequest: z.ZodRecord<z.ZodUUID, z.ZodTuple<[z.ZodObject<{
-    type: z.ZodLiteral<"create">;
+export declare const SyncFillsSinceRequest: z.ZodObject<{
+    overlapMs: z.ZodNumber;
+}, z.core.$strip>;
+export declare const SyncFundingSinceRequest: z.ZodObject<{
+    overlapMs: z.ZodNumber;
+}, z.core.$strip>;
+export type ConfirmFillsRequest = z.output<typeof ConfirmFillsRequest>;
+export type ReconcileFillsRequest = z.output<typeof ReconcileFillsRequest>;
+export type SyncFillsSinceRequest = z.output<typeof SyncFillsSinceRequest>;
+export type SyncFundingSinceRequest = z.output<typeof SyncFundingSinceRequest>;
+export type UnknownExternalFill = z.output<typeof UnknownExternalFill>;
+export type ReconcileReplacementExternalFill = z.output<typeof ReconcileReplacementExternalFill>;
+export type ConfirmableExternalFill = z.output<typeof ConfirmableExternalFill>;
+/**
+ * An exchange-reported open position snapshot. The exchange position API is the
+ * source of truth for current exposure; sizes are normalized to BASE units
+ * (contractSize applied) so gap arithmetic against fills is unit-consistent.
+ */
+export declare const ExternalPosition: z.ZodObject<{
+    symbol: z.ZodString;
+    size: z.ZodString;
+    side: z.ZodEnum<{
+        BUY: "BUY";
+        SELL: "SELL";
+    }>;
+    entryPrice: z.ZodString;
+    markPrice: z.ZodString;
+}, z.core.$strip>;
+export type ExternalPosition = z.output<typeof ExternalPosition>;
+/**
+ * A single fill bound to a positionKey basket. Every fill carries a price/usd:
+ * real and gap/opening synthetics a genuine value, unpriceable gone-close
+ * synthetics "0" (consumers treat 0-price as unpriceable).
+ */
+export declare const ApplicableFill: z.ZodObject<{
     exchangeFillId: z.ZodString;
     cloid: z.ZodNullable<z.ZodString>;
-    positionId: z.ZodUUID;
     connector: z.ZodEnum<{
         hyperliquid: "hyperliquid";
         binance: "binance";
@@ -218,27 +220,205 @@ export declare const CreateFillsRequest: z.ZodRecord<z.ZodUUID, z.ZodTuple<[z.Zo
         lighter: "lighter";
     }>;
     symbol: z.ZodString;
-    price: z.ZodString;
-    quantity: z.ZodString;
     side: z.ZodEnum<{
         BUY: "BUY";
         SELL: "SELL";
     }>;
-    reduceOnly: z.ZodBoolean;
+    quantity: z.ZodString;
+    price: z.ZodString;
+    usd: z.ZodString;
     timestamp: z.ZodNumber;
+    reduceOnly: z.ZodBoolean;
+    synthetic: z.ZodBoolean;
+    isExternal: z.ZodBoolean;
     tradeFee: z.ZodString;
-    liquidation: z.ZodNullable<z.ZodObject<{
+    builderFee: z.ZodString;
+    closedReason: z.ZodOptional<z.ZodEnum<{
+        NETTED: "NETTED";
+        USER: "USER";
+        LIQUIDATED: "LIQUIDATED";
+    }>>;
+    liquidation: z.ZodOptional<z.ZodNullable<z.ZodObject<{
         mark: z.ZodString;
-    }, z.core.$strip>>;
+    }, z.core.$strip>>>;
     original: z.ZodOptional<z.ZodObject<{
         exchangeFillId: z.ZodString;
         quantity: z.ZodString;
     }, z.core.$strip>>;
-}, z.core.$strip>], z.ZodObject<{
-    type: z.ZodLiteral<"create">;
-    exchangeFillId: z.ZodString;
-    cloid: z.ZodNullable<z.ZodString>;
-    positionId: z.ZodUUID;
+}, z.core.$strip>;
+export type ApplicableFill = z.output<typeof ApplicableFill>;
+/**
+ * Position metadata for an applicable. Consumed ONLY when the apply step CREATES a
+ * new position for the positionKey. On merge into an existing position it is
+ * ignored. Origin/status/exposure are carried top-level on ApplicablePosition
+ * (client-authoritative lifecycle), so this holds only creation metadata.
+ */
+export declare const ApplicableMetadata: z.ZodObject<{
+    initialExposureUSD: z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>>;
+}, z.core.$strip>;
+export type ApplicableMetadata = z.output<typeof ApplicableMetadata>;
+/**
+ * A basket of fills bound for find-or-create of one target position, keyed by a
+ * deterministic positionKey computed client-side from (tradeAccountId, symbols).
+ *
+ * The client matcher is the lifecycle authority: it computes the final position
+ * `exposure`, `origin`, and `status` and the server blind-writes them (no
+ * server-side recompute). A flip is two ordered applicables sharing one
+ * positionKey: `{status:CLOSED}` then `{status:OPEN}`.
+ */
+export declare const ApplicablePosition: z.ZodObject<{
+    positionKey: z.ZodString;
+    exposure: z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>>;
+    origin: z.ZodEnum<{
+        PARTIAL: "PARTIAL";
+        PEAR: "PEAR";
+        EXTERNAL: "EXTERNAL";
+    }>;
+    status: z.ZodEnum<{
+        OPEN: "OPEN";
+        CLOSED: "CLOSED";
+    }>;
+    closedReason: z.ZodOptional<z.ZodEnum<{
+        NETTED: "NETTED";
+        USER: "USER";
+        LIQUIDATED: "LIQUIDATED";
+    }>>;
+    fills: z.ZodArray<z.ZodObject<{
+        exchangeFillId: z.ZodString;
+        cloid: z.ZodNullable<z.ZodString>;
+        connector: z.ZodEnum<{
+            hyperliquid: "hyperliquid";
+            binance: "binance";
+            bybit: "bybit";
+            okx: "okx";
+            lighter: "lighter";
+        }>;
+        symbol: z.ZodString;
+        side: z.ZodEnum<{
+            BUY: "BUY";
+            SELL: "SELL";
+        }>;
+        quantity: z.ZodString;
+        price: z.ZodString;
+        usd: z.ZodString;
+        timestamp: z.ZodNumber;
+        reduceOnly: z.ZodBoolean;
+        synthetic: z.ZodBoolean;
+        isExternal: z.ZodBoolean;
+        tradeFee: z.ZodString;
+        builderFee: z.ZodString;
+        closedReason: z.ZodOptional<z.ZodEnum<{
+            NETTED: "NETTED";
+            USER: "USER";
+            LIQUIDATED: "LIQUIDATED";
+        }>>;
+        liquidation: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            mark: z.ZodString;
+        }, z.core.$strip>>>;
+        original: z.ZodOptional<z.ZodObject<{
+            exchangeFillId: z.ZodString;
+            quantity: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    metadata: z.ZodObject<{
+        initialExposureUSD: z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ApplicablePosition = z.output<typeof ApplicablePosition>;
+/**
+ * Cycle-level metadata for the unified sync request.
+ */
+export declare const SyncMeta: z.ZodObject<{
+    externalMaxTs: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export type SyncMeta = z.output<typeof SyncMeta>;
+/**
+ * POST /sync/create request — the discover+apply phase of the cycle.
+ * - applicables: baskets keyed by positionKey, find-or-created during apply.
+ * - exchangePositions: the exchange snapshot, enforced source of truth at verify.
+ * - meta: cycle metadata (watermark).
+ *
+ */
+export declare const CreateApplicablesRequest: z.ZodObject<{
+    applicables: z.ZodArray<z.ZodObject<{
+        positionKey: z.ZodString;
+        exposure: z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>>;
+        origin: z.ZodEnum<{
+            PARTIAL: "PARTIAL";
+            PEAR: "PEAR";
+            EXTERNAL: "EXTERNAL";
+        }>;
+        status: z.ZodEnum<{
+            OPEN: "OPEN";
+            CLOSED: "CLOSED";
+        }>;
+        closedReason: z.ZodOptional<z.ZodEnum<{
+            NETTED: "NETTED";
+            USER: "USER";
+            LIQUIDATED: "LIQUIDATED";
+        }>>;
+        fills: z.ZodArray<z.ZodObject<{
+            exchangeFillId: z.ZodString;
+            cloid: z.ZodNullable<z.ZodString>;
+            connector: z.ZodEnum<{
+                hyperliquid: "hyperliquid";
+                binance: "binance";
+                bybit: "bybit";
+                okx: "okx";
+                lighter: "lighter";
+            }>;
+            symbol: z.ZodString;
+            side: z.ZodEnum<{
+                BUY: "BUY";
+                SELL: "SELL";
+            }>;
+            quantity: z.ZodString;
+            price: z.ZodString;
+            usd: z.ZodString;
+            timestamp: z.ZodNumber;
+            reduceOnly: z.ZodBoolean;
+            synthetic: z.ZodBoolean;
+            isExternal: z.ZodBoolean;
+            tradeFee: z.ZodString;
+            builderFee: z.ZodString;
+            closedReason: z.ZodOptional<z.ZodEnum<{
+                NETTED: "NETTED";
+                USER: "USER";
+                LIQUIDATED: "LIQUIDATED";
+            }>>;
+            liquidation: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                mark: z.ZodString;
+            }, z.core.$strip>>>;
+            original: z.ZodOptional<z.ZodObject<{
+                exchangeFillId: z.ZodString;
+                quantity: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        metadata: z.ZodObject<{
+            initialExposureUSD: z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    exchangePositions: z.ZodArray<z.ZodObject<{
+        symbol: z.ZodString;
+        size: z.ZodString;
+        side: z.ZodEnum<{
+            BUY: "BUY";
+            SELL: "SELL";
+        }>;
+        entryPrice: z.ZodString;
+        markPrice: z.ZodString;
+    }, z.core.$strip>>;
+    meta: z.ZodObject<{
+        externalMaxTs: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type CreateApplicablesRequest = z.output<typeof CreateApplicablesRequest>;
+/**
+ * A single historical funding event for an instrument: the applied funding rate,
+ * the funding amount in USD notional, and the SIGNED funding per 1 unit of size
+ * (notional / szi). All signed (negative when the user paid).
+ */
+export declare const FundingPaymentEntry: z.ZodObject<{
     connector: z.ZodEnum<{
         hyperliquid: "hyperliquid";
         binance: "binance";
@@ -246,34 +426,34 @@ export declare const CreateFillsRequest: z.ZodRecord<z.ZodUUID, z.ZodTuple<[z.Zo
         okx: "okx";
         lighter: "lighter";
     }>;
-    symbol: z.ZodString;
-    price: z.ZodString;
-    quantity: z.ZodString;
-    side: z.ZodEnum<{
-        BUY: "BUY";
-        SELL: "SELL";
-    }>;
-    reduceOnly: z.ZodBoolean;
+    instrumentId: z.ZodString;
+    fundingRate: z.ZodString;
+    notional: z.ZodString;
+    fundingPerUnit: z.ZodString;
     timestamp: z.ZodNumber;
-    tradeFee: z.ZodString;
-    liquidation: z.ZodNullable<z.ZodObject<{
-        mark: z.ZodString;
-    }, z.core.$strip>>;
-    original: z.ZodOptional<z.ZodObject<{
-        exchangeFillId: z.ZodString;
-        quantity: z.ZodString;
+}, z.core.$strip>;
+export type FundingPaymentEntry = z.output<typeof FundingPaymentEntry>;
+/**
+ * POST /sync/funding/create request — funding events since the watermark plus the
+ * cycle watermark. Rows upsert idempotently on (account, connector, instrument, ts).
+ */
+export declare const CreateFundingPaymentsRequest: z.ZodObject<{
+    payments: z.ZodArray<z.ZodObject<{
+        connector: z.ZodEnum<{
+            hyperliquid: "hyperliquid";
+            binance: "binance";
+            bybit: "bybit";
+            okx: "okx";
+            lighter: "lighter";
+        }>;
+        instrumentId: z.ZodString;
+        fundingRate: z.ZodString;
+        notional: z.ZodString;
+        fundingPerUnit: z.ZodString;
+        timestamp: z.ZodNumber;
     }, z.core.$strip>>;
-}, z.core.$strip>>>;
-export declare const SyncSinceRequest: z.ZodObject<{
-    overlapMs: z.ZodNumber;
-    nowMs: z.ZodOptional<z.ZodNumber>;
-    bootstrapLookbackMs: z.ZodOptional<z.ZodNumber>;
+    meta: z.ZodObject<{
+        externalMaxTs: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>;
 }, z.core.$strip>;
-export type ConfirmFillsRequest = z.output<typeof ConfirmFillsRequest>;
-export type ReconcileFillsRequest = z.output<typeof ReconcileFillsRequest>;
-export type CreateFillsRequest = z.output<typeof CreateFillsRequest>;
-export type SyncSinceRequest = z.output<typeof SyncSinceRequest>;
-export type UnknownExternalFill = z.output<typeof UnknownExternalFill>;
-export type ReconcileReplacementExternalFill = z.output<typeof ReconcileReplacementExternalFill>;
-export type ConfirmableExternalFill = z.output<typeof ConfirmableExternalFill>;
-export type CreatableExternalFill = z.output<typeof CreatableExternalFill>;
+export type CreateFundingPaymentsRequest = z.output<typeof CreateFundingPaymentsRequest>;

package/dist/sync/payloads.js

@@ -1,11 +1,19 @@
 import { z } from 'zod';
 import { RefineMinimumOneKeyValuePair } from '../common/refinement';
-import { UnsignedDecimalString, Side } from '../common/schema';
+import { UnsignedDecimalString, Side, SignedDecimalString } from '../common/schema';
 import { Connector } from '../connector';
 import { InstrumentId } from '../instrument';
+import { PositionClosedReason, PositionStatus, PositionOrigin } from '../position/entities';
 
+const ExchangeFillId = z.string().trim().min(1, "Exchange fill ID must be non-empty");
+const MsTimestamp = z.number().int().positive().describe("Unix timestamp in milliseconds");
+const LiquidationMark = z.object({ mark: UnsignedDecimalString }).nullable();
+const OriginalFillRef = z.object({
+  exchangeFillId: ExchangeFillId,
+  quantity: UnsignedDecimalString
+});
 const UnknownExternalFill = z.object({
-  exchangeFillId: z.string().trim().min(1, "Exchange fill ID must be non-empty"),
+  exchangeFillId: ExchangeFillId,
   cloid: z.string().nullable(),
   connector: Connector,
   symbol: InstrumentId,
@@ -13,25 +21,25 @@ const UnknownExternalFill = z.object({
   quantity: UnsignedDecimalString,
   side: Side,
   reduceOnly: z.boolean(),
-  timestamp: z.number().int().positive().describe("Unix timestamp in milliseconds"),
+  timestamp: MsTimestamp,
   tradeFee: UnsignedDecimalString,
   builderFee: UnsignedDecimalString,
-  liquidation: z.object({ mark: UnsignedDecimalString }).nullable()
+  liquidation: LiquidationMark
 });
 const ConfirmableExternalFill = z.object({
   type: z.literal("confirm"),
-  exchangeFillId: z.string().trim().min(1, "Exchange fill ID must be non-empty"),
+  exchangeFillId: ExchangeFillId,
   cloid: z.string(),
   positionId: z.uuid().describe("Position ID"),
   connector: Connector,
   symbol: InstrumentId,
   quantity: UnsignedDecimalString,
-  timestamp: z.number().int().positive().describe("Unix timestamp in milliseconds"),
+  timestamp: MsTimestamp,
   tradeFee: UnsignedDecimalString,
   builderFee: UnsignedDecimalString
 });
 const ReconcileReplacementExternalFill = z.object({
-  exchangeFillId: z.string().trim().min(1, "Exchange fill ID must be non-empty"),
+  exchangeFillId: ExchangeFillId,
   cloid: z.string(),
   connector: Connector,
   symbol: InstrumentId,
@@ -39,40 +47,84 @@ const ReconcileReplacementExternalFill = z.object({
   quantity: UnsignedDecimalString,
   side: Side,
   reduceOnly: z.boolean(),
-  timestamp: z.number().int().positive().describe("Unix timestamp in milliseconds"),
+  timestamp: MsTimestamp,
   tradeFee: UnsignedDecimalString,
   builderFee: UnsignedDecimalString,
-  liquidation: z.object({ mark: UnsignedDecimalString }).nullable()
+  liquidation: LiquidationMark
+});
+const ConfirmFillsRequest = z.record(z.uuid().describe("Position ID"), z.tuple([ConfirmableExternalFill]).rest(ConfirmableExternalFill)).superRefine(RefineMinimumOneKeyValuePair);
+const ReconcileFillsRequest = z.record(
+  z.string().trim().min(1, "CLOID must be non-empty"),
+  z.tuple([ReconcileReplacementExternalFill, ReconcileReplacementExternalFill]).rest(ReconcileReplacementExternalFill)
+).superRefine(RefineMinimumOneKeyValuePair);
+const SyncFillsSinceRequest = z.object({
+  overlapMs: z.number().int().positive()
 });
-const CreatableExternalFill = z.object({
-  type: z.literal("create"),
-  exchangeFillId: z.string().trim().min(1, "Exchange fill ID must be non-empty"),
+const SyncFundingSinceRequest = z.object({
+  overlapMs: z.number().int().positive()
+});
+const ExternalPosition = z.object({
+  symbol: InstrumentId,
+  size: UnsignedDecimalString.describe("BASE units, contractSize applied; always >= 0"),
+  side: Side.describe("sign of the net position"),
+  entryPrice: UnsignedDecimalString.describe("exchange-reported average entry"),
+  markPrice: UnsignedDecimalString
+});
+const ApplicableFill = z.object({
+  // Deterministic synthetic id (`synthetic-{positionKey}-{symbol}-{side}`) for synthetic fills,
+  // exchange-native id for real fills.
+  exchangeFillId: ExchangeFillId,
   cloid: z.string().nullable(),
-  positionId: z.uuid().describe("Position ID"),
   connector: Connector,
   symbol: InstrumentId,
-  price: UnsignedDecimalString,
-  quantity: UnsignedDecimalString,
   side: Side,
+  quantity: UnsignedDecimalString.describe("BASE units"),
+  price: UnsignedDecimalString.describe('"0" only on an unpriceable gone-close synthetic'),
+  usd: UnsignedDecimalString.describe('"0" only on an unpriceable gone-close synthetic'),
+  timestamp: MsTimestamp.describe("ms \u2014 apply replays in this order"),
   reduceOnly: z.boolean(),
-  timestamp: z.number().int().positive().describe("Unix timestamp in milliseconds"),
+  synthetic: z.boolean(),
+  isExternal: z.boolean(),
   tradeFee: UnsignedDecimalString,
-  liquidation: z.object({ mark: UnsignedDecimalString }).nullable(),
-  original: z.object({
-    exchangeFillId: z.string().trim().min(1, "Exchange fill ID must be non-empty"),
-    quantity: UnsignedDecimalString
-  }).optional()
+  builderFee: UnsignedDecimalString,
+  closedReason: PositionClosedReason.optional().describe("e.g. NETTED for a synthetic close fill"),
+  liquidation: LiquidationMark.optional(),
+  original: OriginalFillRef.optional()
 });
-const ConfirmFillsRequest = z.record(z.uuid().describe("Position ID"), z.tuple([ConfirmableExternalFill]).rest(ConfirmableExternalFill)).superRefine(RefineMinimumOneKeyValuePair);
-const ReconcileFillsRequest = z.record(
-  z.string().trim().min(1, "CLOID must be non-empty"),
-  z.tuple([ReconcileReplacementExternalFill, ReconcileReplacementExternalFill]).rest(ReconcileReplacementExternalFill)
-).superRefine(RefineMinimumOneKeyValuePair);
-const CreateFillsRequest = z.record(z.uuid().describe("Position ID"), z.tuple([CreatableExternalFill]).rest(CreatableExternalFill)).superRefine(RefineMinimumOneKeyValuePair);
-const SyncSinceRequest = z.object({
-  overlapMs: z.number().int().positive(),
-  nowMs: z.number().int().nonnegative().optional(),
-  bootstrapLookbackMs: z.number().int().positive().optional()
+const ApplicableMetadata = z.object({
+  initialExposureUSD: z.record(InstrumentId, SignedDecimalString).describe("opening cost basis from this position\u2019s own real fills; partial map allowed")
+});
+const ApplicablePosition = z.object({
+  positionKey: z.string().trim().min(1, "positionKey must be non-empty"),
+  exposure: z.record(InstrumentId, SignedDecimalString).describe("final position exposure (signed, BASE units)"),
+  origin: PositionOrigin,
+  status: PositionStatus,
+  closedReason: PositionClosedReason.optional().describe("set when status is CLOSED, e.g. NETTED"),
+  fills: z.array(ApplicableFill).min(1, "Applicable must carry at least one fill"),
+  metadata: ApplicableMetadata
+});
+const SyncMeta = z.object({
+  externalMaxTs: z.number().int().nonnegative().nullable().describe("watermark advance source")
+});
+const CreateApplicablesRequest = z.object({
+  applicables: z.array(ApplicablePosition),
+  exchangePositions: z.array(ExternalPosition),
+  meta: SyncMeta
+});
+const OptionallySignedDecimalString = z.string().regex(/^[+-]?\d+(\.\d+)?$/, "Must be a valid signed decimal string");
+const FundingPaymentEntry = z.object({
+  connector: Connector,
+  instrumentId: InstrumentId,
+  fundingRate: OptionallySignedDecimalString.describe("applied funding rate, optionally signed"),
+  notional: OptionallySignedDecimalString.describe("funding amount in USD notional, optionally signed"),
+  fundingPerUnit: OptionallySignedDecimalString.describe(
+    "signed funding per 1 unit of size (notional / szi); attribution coefficient"
+  ),
+  timestamp: MsTimestamp
+});
+const CreateFundingPaymentsRequest = z.object({
+  payments: z.array(FundingPaymentEntry),
+  meta: SyncMeta
 });
 
-export { ConfirmFillsRequest, ConfirmableExternalFill, CreatableExternalFill, CreateFillsRequest, ReconcileFillsRequest, ReconcileReplacementExternalFill, SyncSinceRequest, UnknownExternalFill };
+export { ApplicableFill, ApplicableMetadata, ApplicablePosition, ConfirmFillsRequest, ConfirmableExternalFill, CreateApplicablesRequest, CreateFundingPaymentsRequest, ExternalPosition, FundingPaymentEntry, ReconcileFillsRequest, ReconcileReplacementExternalFill, SyncFillsSinceRequest, SyncFundingSinceRequest, SyncMeta, UnknownExternalFill };

package/dist/sync/responses.d.ts

@@ -1,10 +1,13 @@
 import { z } from 'zod';
 export declare const SyncFillsResponse: z.ZodObject<{}, z.core.$strip>;
-export declare const SyncSinceResponse: z.ZodObject<{
-    since: z.ZodISODateTime;
+export declare const SyncFillsSinceResponse: z.ZodObject<{
     sinceMs: z.ZodNumber;
-    safeTs: z.ZodOptional<z.ZodNumber>;
+    neverSynced: z.ZodBoolean;
     confirmedExchangeFillIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
+export declare const SyncFundingSinceResponse: z.ZodObject<{
+    sinceMs: z.ZodNumber;
+}, z.core.$strip>;
 export type SyncFillsResponse = z.output<typeof SyncFillsResponse>;
-export type SyncSinceResponse = z.output<typeof SyncSinceResponse>;
+export type SyncFillsSinceResponse = z.output<typeof SyncFillsSinceResponse>;
+export type SyncFundingSinceResponse = z.output<typeof SyncFundingSinceResponse>;

package/dist/sync/responses.js

@@ -1,11 +1,16 @@
 import { z } from 'zod';
 
 const SyncFillsResponse = z.object({});
-const SyncSinceResponse = z.object({
-  since: z.iso.datetime(),
+const SyncFillsSinceResponse = z.object({
   sinceMs: z.number().int().nonnegative(),
-  safeTs: z.number().int().nonnegative().optional(),
+  // True only when the account has no checkpoint and nothing to anchor on, so sync starts from
+  // genesis. Clients use this to detect an account that has never imported its trade history —
+  // `sinceMs === 0` alone is ambiguous (a clamped watermark also yields 0).
+  neverSynced: z.boolean(),
   confirmedExchangeFillIds: z.array(z.string()).optional()
 });
+const SyncFundingSinceResponse = z.object({
+  sinceMs: z.number().int().nonnegative()
+});
 
-export { SyncFillsResponse, SyncSinceResponse };
+export { SyncFillsResponse, SyncFillsSinceResponse, SyncFundingSinceResponse };