@pear-protocol/types 1.7.0 → 1.9.0

package/dist/common/response.d.ts

@@ -7,6 +7,6 @@ export declare const PaginatedResponse: z.ZodObject<{
 export type PaginatedResponse = z.output<typeof PaginatedResponse>;
 export declare const CursorResponse: z.ZodObject<{
     limit: z.ZodNumber;
-    nextCursor: z.ZodUnion<[z.ZodString, z.ZodUndefined]>;
+    nextCursor: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type CursorResponse = z.output<typeof CursorResponse>;

package/dist/common/response.js

@@ -22,7 +22,7 @@ const CursorResponse = z.object({
   /**
    * The cursor to use for pagination.
    */
-  nextCursor: z.string().or(z.undefined())
+  nextCursor: z.string().optional()
 });
 
 export { CursorResponse, PaginatedResponse };

package/dist/execution/responses.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 export declare const ExecutionListResponse: z.ZodObject<{
     limit: z.ZodNumber;
-    nextCursor: z.ZodUnion<[z.ZodString, z.ZodUndefined]>;
+    nextCursor: z.ZodOptional<z.ZodString>;
     executions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodDiscriminatedUnion<[z.ZodObject<{
         id: z.ZodUUID;
         connector: z.ZodEnum<{
@@ -279,3 +279,281 @@ export declare const ExecutionListResponse: z.ZodObject<{
     }, z.core.$strip>], "intent">], "orderType">>;
 }, z.core.$strip>;
 export type ExecutionListResponse = z.output<typeof ExecutionListResponse>;
+export declare const GetExecutionResponse: z.ZodObject<{
+    execution: z.ZodDiscriminatedUnion<[z.ZodDiscriminatedUnion<[z.ZodObject<{
+        id: z.ZodUUID;
+        connector: z.ZodEnum<{
+            hyperliquid: "hyperliquid";
+            binance: "binance";
+            bybit: "bybit";
+            okx: "okx";
+            lighter: "lighter";
+        }>;
+        status: z.ZodEnum<{
+            CANCELLED: "CANCELLED";
+            IDLE: "IDLE";
+            ACTIVE: "ACTIVE";
+            COMPLETED: "COMPLETED";
+            FAILED: "FAILED";
+        }>;
+        error: z.ZodOptional<z.ZodString>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+        orders: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            id: z.ZodUUID;
+            connector: z.ZodEnum<{
+                hyperliquid: "hyperliquid";
+                binance: "binance";
+                bybit: "bybit";
+                okx: "okx";
+                lighter: "lighter";
+            }>;
+            status: z.ZodEnum<{
+                PENDING: "PENDING";
+                PARTIAL: "PARTIAL";
+                FILLED: "FILLED";
+                CANCELLED: "CANCELLED";
+                REJECTED: "REJECTED";
+            }>;
+            error: z.ZodOptional<z.ZodString>;
+            createdAt: z.ZodString;
+            updatedAt: z.ZodString;
+            type: z.ZodLiteral<"MARKET">;
+            symbol: z.ZodString;
+            side: z.ZodEnum<{
+                BUY: "BUY";
+                SELL: "SELL";
+            }>;
+            reduceOnly: z.ZodBoolean;
+            leverage: z.ZodInt;
+            quantity: z.ZodString;
+            price: z.ZodString;
+            filledQuantity: z.ZodString;
+            filledPrice: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>], "type">>>;
+        intent: z.ZodLiteral<"OPEN">;
+        orderType: z.ZodLiteral<"MARKET">;
+        legs: z.ZodTuple<[z.ZodObject<{
+            symbol: z.ZodString;
+            side: z.ZodEnum<{
+                BUY: "BUY";
+                SELL: "SELL";
+            }>;
+            mode: z.ZodEnum<{
+                QUANTITY: "QUANTITY";
+                USD: "USD";
+            }>;
+            amount: z.ZodString;
+            reduceOnly: z.ZodBoolean;
+        }, z.core.$strip>], z.ZodObject<{
+            symbol: z.ZodString;
+            side: z.ZodEnum<{
+                BUY: "BUY";
+                SELL: "SELL";
+            }>;
+            mode: z.ZodEnum<{
+                QUANTITY: "QUANTITY";
+                USD: "USD";
+            }>;
+            amount: z.ZodString;
+            reduceOnly: z.ZodBoolean;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodUUID;
+        connector: z.ZodEnum<{
+            hyperliquid: "hyperliquid";
+            binance: "binance";
+            bybit: "bybit";
+            okx: "okx";
+            lighter: "lighter";
+        }>;
+        status: z.ZodEnum<{
+            CANCELLED: "CANCELLED";
+            IDLE: "IDLE";
+            ACTIVE: "ACTIVE";
+            COMPLETED: "COMPLETED";
+            FAILED: "FAILED";
+        }>;
+        error: z.ZodOptional<z.ZodString>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+        orders: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            id: z.ZodUUID;
+            connector: z.ZodEnum<{
+                hyperliquid: "hyperliquid";
+                binance: "binance";
+                bybit: "bybit";
+                okx: "okx";
+                lighter: "lighter";
+            }>;
+            status: z.ZodEnum<{
+                PENDING: "PENDING";
+                PARTIAL: "PARTIAL";
+                FILLED: "FILLED";
+                CANCELLED: "CANCELLED";
+                REJECTED: "REJECTED";
+            }>;
+            error: z.ZodOptional<z.ZodString>;
+            createdAt: z.ZodString;
+            updatedAt: z.ZodString;
+            type: z.ZodLiteral<"MARKET">;
+            symbol: z.ZodString;
+            side: z.ZodEnum<{
+                BUY: "BUY";
+                SELL: "SELL";
+            }>;
+            reduceOnly: z.ZodBoolean;
+            leverage: z.ZodInt;
+            quantity: z.ZodString;
+            price: z.ZodString;
+            filledQuantity: z.ZodString;
+            filledPrice: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>], "type">>>;
+        intent: z.ZodLiteral<"ADJUST">;
+        orderType: z.ZodLiteral<"MARKET">;
+        position: z.ZodObject<{
+            id: z.ZodUUID;
+            exposure: z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>>;
+        }, z.core.$strip>;
+        legs: z.ZodTuple<[z.ZodObject<{
+            symbol: z.ZodString;
+            side: z.ZodEnum<{
+                BUY: "BUY";
+                SELL: "SELL";
+            }>;
+            mode: z.ZodEnum<{
+                QUANTITY: "QUANTITY";
+                USD: "USD";
+            }>;
+            amount: z.ZodString;
+            reduceOnly: z.ZodBoolean;
+        }, z.core.$strip>], z.ZodObject<{
+            symbol: z.ZodString;
+            side: z.ZodEnum<{
+                BUY: "BUY";
+                SELL: "SELL";
+            }>;
+            mode: z.ZodEnum<{
+                QUANTITY: "QUANTITY";
+                USD: "USD";
+            }>;
+            amount: z.ZodString;
+            reduceOnly: z.ZodBoolean;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodUUID;
+        connector: z.ZodEnum<{
+            hyperliquid: "hyperliquid";
+            binance: "binance";
+            bybit: "bybit";
+            okx: "okx";
+            lighter: "lighter";
+        }>;
+        status: z.ZodEnum<{
+            CANCELLED: "CANCELLED";
+            IDLE: "IDLE";
+            ACTIVE: "ACTIVE";
+            COMPLETED: "COMPLETED";
+            FAILED: "FAILED";
+        }>;
+        error: z.ZodOptional<z.ZodString>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+        orders: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            id: z.ZodUUID;
+            connector: z.ZodEnum<{
+                hyperliquid: "hyperliquid";
+                binance: "binance";
+                bybit: "bybit";
+                okx: "okx";
+                lighter: "lighter";
+            }>;
+            status: z.ZodEnum<{
+                PENDING: "PENDING";
+                PARTIAL: "PARTIAL";
+                FILLED: "FILLED";
+                CANCELLED: "CANCELLED";
+                REJECTED: "REJECTED";
+            }>;
+            error: z.ZodOptional<z.ZodString>;
+            createdAt: z.ZodString;
+            updatedAt: z.ZodString;
+            type: z.ZodLiteral<"MARKET">;
+            symbol: z.ZodString;
+            side: z.ZodEnum<{
+                BUY: "BUY";
+                SELL: "SELL";
+            }>;
+            reduceOnly: z.ZodBoolean;
+            leverage: z.ZodInt;
+            quantity: z.ZodString;
+            price: z.ZodString;
+            filledQuantity: z.ZodString;
+            filledPrice: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>], "type">>>;
+        intent: z.ZodLiteral<"CLOSE">;
+        orderType: z.ZodLiteral<"MARKET">;
+        position: z.ZodObject<{
+            id: z.ZodUUID;
+            exposure: z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodUUID;
+        connector: z.ZodEnum<{
+            hyperliquid: "hyperliquid";
+            binance: "binance";
+            bybit: "bybit";
+            okx: "okx";
+            lighter: "lighter";
+        }>;
+        status: z.ZodEnum<{
+            CANCELLED: "CANCELLED";
+            IDLE: "IDLE";
+            ACTIVE: "ACTIVE";
+            COMPLETED: "COMPLETED";
+            FAILED: "FAILED";
+        }>;
+        error: z.ZodOptional<z.ZodString>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+        orders: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            id: z.ZodUUID;
+            connector: z.ZodEnum<{
+                hyperliquid: "hyperliquid";
+                binance: "binance";
+                bybit: "bybit";
+                okx: "okx";
+                lighter: "lighter";
+            }>;
+            status: z.ZodEnum<{
+                PENDING: "PENDING";
+                PARTIAL: "PARTIAL";
+                FILLED: "FILLED";
+                CANCELLED: "CANCELLED";
+                REJECTED: "REJECTED";
+            }>;
+            error: z.ZodOptional<z.ZodString>;
+            createdAt: z.ZodString;
+            updatedAt: z.ZodString;
+            type: z.ZodLiteral<"MARKET">;
+            symbol: z.ZodString;
+            side: z.ZodEnum<{
+                BUY: "BUY";
+                SELL: "SELL";
+            }>;
+            reduceOnly: z.ZodBoolean;
+            leverage: z.ZodInt;
+            quantity: z.ZodString;
+            price: z.ZodString;
+            filledQuantity: z.ZodString;
+            filledPrice: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>], "type">>>;
+        intent: z.ZodLiteral<"REVERSE">;
+        orderType: z.ZodLiteral<"MARKET">;
+        position: z.ZodObject<{
+            id: z.ZodUUID;
+            exposure: z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>], "intent">], "orderType">;
+}, z.core.$strip>;
+export type GetExecutionResponse = z.output<typeof GetExecutionResponse>;

package/dist/execution/responses.js

@@ -5,5 +5,6 @@ import { Execution } from './entities';
 const ExecutionListResponse = CursorResponse.extend({
   executions: z.array(Execution)
 });
+const GetExecutionResponse = z.object({ execution: Execution });
 
-export { ExecutionListResponse };
+export { ExecutionListResponse, GetExecutionResponse };

package/dist/fill/responses.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 export declare const FillListResponse: z.ZodObject<{
     limit: z.ZodNumber;
-    nextCursor: z.ZodUnion<[z.ZodString, z.ZodUndefined]>;
+    nextCursor: z.ZodOptional<z.ZodString>;
     fills: z.ZodArray<z.ZodObject<{
         id: z.ZodUUID;
         cloid: z.ZodOptional<z.ZodString>;

package/dist/ladder/responses.d.ts

@@ -1509,7 +1509,7 @@ export declare const LadderResponse: z.ZodObject<{
 export type LadderResponse = z.output<typeof LadderResponse>;
 export declare const LadderListResponse: z.ZodObject<{
     limit: z.ZodNumber;
-    nextCursor: z.ZodUnion<[z.ZodString, z.ZodUndefined]>;
+    nextCursor: z.ZodOptional<z.ZodString>;
     ladders: z.ZodArray<z.ZodObject<{
         id: z.ZodUUID;
         connector: z.ZodEnum<{

package/dist/position/entities.d.ts

@@ -49,6 +49,14 @@ export type PositionInitialExposureUSD = z.infer<typeof PositionInitialExposureU
  */
 export declare const PositionTotalFundingPayment: z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>>;
 export type PositionTotalFundingPayment = z.infer<typeof PositionTotalFundingPayment>;
+/**
+ * Weighted-average entry (cost-basis) price for each asset in the position, derived from the
+ * fills ledger. An instrument is absent when it has no fill history to derive a cost basis from.
+ *
+ * @example { '0': '95000' } means BTC's cost basis is 95000 USD.
+ */
+export declare const PositionEntryPrices: z.ZodRecord<z.ZodString, z.ZodString>;
+export type PositionEntryPrices = z.infer<typeof PositionEntryPrices>;
 export declare const Position: z.ZodObject<{
     id: z.ZodUUID;
     tradeAccountId: z.ZodUUID;
@@ -77,6 +85,7 @@ export declare const Position: z.ZodObject<{
     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>>>;
+    entryPrices: z.ZodRecord<z.ZodString, z.ZodString>;
     createdAt: z.ZodString;
     updatedAt: z.ZodString;
 }, z.core.$strip>;

package/dist/position/entities.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { SignedDecimalString } from '../common/schema';
+import { SignedDecimalString, UnsignedDecimalString } from '../common/schema';
 import { Connector } from '../connector';
 import { InstrumentId } from '../instrument';
 
@@ -9,6 +9,7 @@ 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
@@ -46,8 +47,14 @@ const Position = z.object({
    * 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.
+   */
+  entryPrices: PositionEntryPrices,
   createdAt: z.string(),
   updatedAt: z.string()
 });
 
-export { Position, PositionClosedReason, PositionExposure, PositionInitialExposureUSD, PositionOrigin, PositionStatus, PositionTotalFundingPayment };
+export { Position, PositionClosedReason, PositionEntryPrices, PositionExposure, PositionInitialExposureUSD, PositionOrigin, PositionStatus, PositionTotalFundingPayment };

package/dist/position/queries.d.ts

@@ -1,5 +1,7 @@
 import { z } from 'zod';
 export declare const PositionListParams: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<number>>>;
+    cursor: z.ZodOptional<z.ZodString>;
     connector: z.ZodOptional<z.ZodEnum<{
         hyperliquid: "hyperliquid";
         binance: "binance";

package/dist/position/queries.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { normalizeArray } from '../common';
+import { normalizeArray, CursorFindParams } from '../common';
 import { Connector } from '../connector';
 
 const OrderBy = z.union([
@@ -10,7 +10,7 @@ const OrderBy = z.union([
 ]);
 const StatusEnum = z.enum(["OPEN", "CLOSED"]);
 const StatusArray = z.preprocess((arg) => normalizeArray(arg), z.array(StatusEnum));
-const PositionListParams = z.object({
+const PositionListParams = CursorFindParams.extend({
   /**
    * Connector filter
    */

package/dist/position/responses.d.ts

@@ -1,5 +1,7 @@
 import { z } from 'zod';
 export declare const PositionListResponse: z.ZodObject<{
+    limit: z.ZodNumber;
+    nextCursor: z.ZodOptional<z.ZodString>;
     positions: z.ZodArray<z.ZodObject<{
         id: z.ZodUUID;
         tradeAccountId: z.ZodUUID;
@@ -28,6 +30,7 @@ export declare const PositionListResponse: z.ZodObject<{
         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>>>;
+        entryPrices: z.ZodRecord<z.ZodString, z.ZodString>;
         createdAt: z.ZodString;
         updatedAt: z.ZodString;
     }, z.core.$strip>>;

package/dist/position/responses.js

@@ -1,10 +1,11 @@
 import { z } from 'zod';
+import { CursorResponse } from '../common';
 import { SignedDecimalString } from '../common/schema';
 import { Connector } from '../connector';
 import { InstrumentId } from '../instrument';
 import { Position, PositionOrigin } from './entities';
 
-const PositionListResponse = z.object({
+const PositionListResponse = CursorResponse.extend({
   positions: z.array(Position)
 });
 const OpenPositionLite = z.object({

package/dist/rebalance/responses.d.ts

@@ -16,7 +16,7 @@ export declare const RebalanceManualResponse: z.ZodObject<{
 export type RebalanceManualResponse = z.output<typeof RebalanceManualResponse>;
 export declare const AutoRebalanceListResponse: z.ZodObject<{
     limit: z.ZodNumber;
-    nextCursor: z.ZodUnion<[z.ZodString, z.ZodUndefined]>;
+    nextCursor: z.ZodOptional<z.ZodString>;
     items: z.ZodArray<z.ZodObject<{
         id: z.ZodUUID;
         positionId: z.ZodUUID;
@@ -64,7 +64,7 @@ export declare const CreateAutoRebalanceResponse: z.ZodObject<{
 export type CreateAutoRebalanceResponse = z.output<typeof CreateAutoRebalanceResponse>;
 export declare const RebalanceEventListResponse: z.ZodObject<{
     limit: z.ZodNumber;
-    nextCursor: z.ZodUnion<[z.ZodString, z.ZodUndefined]>;
+    nextCursor: z.ZodOptional<z.ZodString>;
     items: z.ZodArray<z.ZodObject<{
         id: z.ZodUUID;
         autoRebalanceConfigId: z.ZodUUID;

package/dist/schedule/payloads.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-declare const CreateTWAPOpen: z.ZodObject<{
+export declare const CreateTWAPOpen: z.ZodObject<{
     startAt: z.ZodPipe<z.ZodOptional<z.ZodCoercedDate<unknown>>, z.ZodTransform<Date, Date | undefined>>;
     endAt: z.ZodPipe<z.ZodOptional<z.ZodCoercedDate<unknown>>, z.ZodTransform<Date, Date | undefined>>;
     strategy: z.ZodLiteral<"TWAP">;
@@ -21,7 +21,7 @@ declare const CreateTWAPOpen: z.ZodObject<{
     sliceIntervalSec: z.ZodInt;
     clientId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
-declare const CreateTWAPClose: z.ZodObject<{
+export declare const CreateTWAPClose: z.ZodObject<{
     startAt: z.ZodPipe<z.ZodOptional<z.ZodCoercedDate<unknown>>, z.ZodTransform<Date, Date | undefined>>;
     endAt: z.ZodPipe<z.ZodOptional<z.ZodCoercedDate<unknown>>, z.ZodTransform<Date, Date | undefined>>;
     strategy: z.ZodLiteral<"TWAP">;
@@ -73,4 +73,3 @@ export declare const CreateSchedule: z.ZodDiscriminatedUnion<[z.ZodObject<{
 export type CreateTWAPOpen = z.output<typeof CreateTWAPOpen>;
 export type CreateTWAPClose = z.output<typeof CreateTWAPClose>;
 export type CreateSchedule = z.output<typeof CreateSchedule>;
-export {};

package/dist/schedule/payloads.js

@@ -112,4 +112,4 @@ const CreateTWAPClose = BaseSchedule.safeExtend({
 });
 const CreateSchedule = z.discriminatedUnion("intent", [CreateTWAPOpen, CreateTWAPClose]);
 
-export { CreateSchedule };
+export { CreateSchedule, CreateTWAPClose, CreateTWAPOpen };

package/dist/schedule/responses.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 export declare const ScheduleListResponse: z.ZodObject<{
     limit: z.ZodNumber;
-    nextCursor: z.ZodUnion<[z.ZodString, z.ZodUndefined]>;
+    nextCursor: z.ZodOptional<z.ZodString>;
     schedules: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         id: z.ZodUUID;
         connector: z.ZodEnum<{

package/dist/statistics/entities.d.ts

@@ -14,3 +14,10 @@ export declare const OiStatistics: z.ZodObject<{
     openPositions: z.ZodNumber;
 }, z.core.$strip>;
 export type OiStatistics = z.output<typeof OiStatistics>;
+export declare const StatisticsTotals: z.ZodObject<{
+    totalVolume: z.ZodNumber;
+    totalFees: z.ZodNumber;
+    totalTrades: z.ZodNumber;
+    totalUsers: z.ZodNumber;
+}, z.core.$strip>;
+export type StatisticsTotals = z.output<typeof StatisticsTotals>;

package/dist/statistics/entities.js

@@ -13,5 +13,11 @@ const OiStatistics = z.object({
   openInterest: z.number(),
   openPositions: z.number()
 });
+const StatisticsTotals = z.object({
+  totalVolume: z.number(),
+  totalFees: z.number(),
+  totalTrades: z.number(),
+  totalUsers: z.number()
+});
 
-export { OiStatistics, VolumeStatistics };
+export { OiStatistics, StatisticsTotals, VolumeStatistics };

package/dist/statistics/queries.d.ts

@@ -35,3 +35,14 @@ export declare const OiStatisticsQueryParams: z.ZodObject<{
 }, z.core.$strip>;
 export type OiStatisticsQueryParamsInput = z.input<typeof OiStatisticsQueryParams>;
 export type OiStatisticsQueryParams = z.output<typeof OiStatisticsQueryParams>;
+export declare const StatisticsTotalsQueryParams: z.ZodObject<{
+    connector: z.ZodEnum<{
+        hyperliquid: "hyperliquid";
+        binance: "binance";
+        bybit: "bybit";
+        okx: "okx";
+        lighter: "lighter";
+    }>;
+}, z.core.$strip>;
+export type StatisticsTotalsQueryParamsInput = z.input<typeof StatisticsTotalsQueryParams>;
+export type StatisticsTotalsQueryParams = z.output<typeof StatisticsTotalsQueryParams>;

package/dist/statistics/queries.js

@@ -17,5 +17,8 @@ const OiStatisticsQueryParams = z.object({
 }).refine((data) => !data.startDate || data.startDate < data.endDate, {
   message: "startDate must be before endDate"
 });
+const StatisticsTotalsQueryParams = z.object({
+  connector: Connector
+});
 
-export { OiStatisticsQueryParams, VolumeStatisticsQueryParams };
+export { OiStatisticsQueryParams, StatisticsTotalsQueryParams, VolumeStatisticsQueryParams };

package/dist/statistics/responses.d.ts

@@ -18,3 +18,12 @@ export declare const OiStatisticsResponse: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type OiStatisticsResponse = z.output<typeof OiStatisticsResponse>;
+export declare const StatisticsTotalsResponse: z.ZodObject<{
+    data: z.ZodObject<{
+        totalVolume: z.ZodNumber;
+        totalFees: z.ZodNumber;
+        totalTrades: z.ZodNumber;
+        totalUsers: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type StatisticsTotalsResponse = z.output<typeof StatisticsTotalsResponse>;

package/dist/statistics/responses.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { VolumeStatistics, OiStatistics } from './entities';
+import { VolumeStatistics, OiStatistics, StatisticsTotals } from './entities';
 
 const VolumeStatisticsResponse = z.object({
   data: z.array(VolumeStatistics)
@@ -7,5 +7,8 @@ const VolumeStatisticsResponse = z.object({
 const OiStatisticsResponse = z.object({
   data: z.array(OiStatistics)
 });
+const StatisticsTotalsResponse = z.object({
+  data: StatisticsTotals
+});
 
-export { OiStatisticsResponse, VolumeStatisticsResponse };
+export { OiStatisticsResponse, StatisticsTotalsResponse, VolumeStatisticsResponse };

package/dist/trigger/responses.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 export declare const TriggerListResponse: z.ZodObject<{
     limit: z.ZodNumber;
-    nextCursor: z.ZodUnion<[z.ZodString, z.ZodUndefined]>;
+    nextCursor: z.ZodOptional<z.ZodString>;
     triggers: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodDiscriminatedUnion<[z.ZodObject<{
         id: z.ZodUUID;
         tradeAccountId: z.ZodUUID;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pear-protocol/types",
-  "version": "1.7.0",
+  "version": "1.9.0",
   "description": "Pear Protocol Types definitions",
   "private": false,
   "type": "module",