@pear-protocol/hyperliquid-sdk 0.0.12 → 0.0.15

package/dist/client.d.ts

@@ -1,4 +1,4 @@
-import { PearHyperliquidConfig, ApiResponse, SyncTradeHistoryDto, SyncTradeHistoryResponseDto, SyncOpenPositionDto, SyncOpenPositionResponseDto, SyncOpenOrderDto, SyncOpenOrderResponseDto } from './types';
+import { PearHyperliquidConfig, ApiResponse, SyncTradeHistoryDto, SyncTradeHistoryResponseDto, SyncOpenPositionDto, SyncOpenPositionResponseDto, SyncOpenOrderDto, SyncOpenOrderResponseDto, CandleData } from './types';
 /**
  * Main SDK client for Pear Protocol Hyperliquid API integration
  */
@@ -40,4 +40,13 @@ export declare class PearHyperliquidClient {
      * @returns Promise with sync result
      */
     syncOpenOrders(payload: SyncOpenOrderDto): Promise<ApiResponse<SyncOpenOrderResponseDto>>;
+    /**
+     * Fetch historical candle data from HyperLiquid API
+     * @param coin - Token symbol (e.g., 'BTC', 'ETH')
+     * @param startTime - Start time in milliseconds
+     * @param endTime - End time in milliseconds
+     * @param interval - Candle interval
+     * @returns Promise with historical candle data
+     */
+    fetchHistoricalCandles(coin: string, startTime: number, endTime: number, interval: string): Promise<ApiResponse<CandleData[]>>;
 }

package/dist/hooks/index.d.ts

@@ -1,6 +1,7 @@
-export { useAddress } from './useAddress';
-export { useTradeHistories, useOpenPositions, useOpenOrders, useAccountSummary } from './useTrading';
-export { useCalculatedOpenPositions } from './useCalculatedPositions';
-export { useCalculatedAccountSummary } from './useCalculatedAccountSummary';
-export { useTokenSelection } from './useTokenSelection';
-export type { TokenSelectorConfig, UseTokenSelectionReturn } from './useTokenSelection';
+export * from './useAddress';
+export * from './useTrading';
+export * from './useUserSelection';
+export * from './useWebData';
+export * from './useTokenSelectionMetadata';
+export * from './useHistoricalPriceData';
+export * from './useBasketCandles';

package/dist/hooks/useBasketCandles.d.ts

@@ -0,0 +1,12 @@
+import type { WeightedCandleData } from '../types';
+export interface UseBasketCandlesReturn {
+    fetchBasketCandles: (startTime: number, endTime: number) => Promise<WeightedCandleData[]>;
+    isLoading: boolean;
+}
+/**
+ * Composes historical price fetching with basket candle computation.
+ * - Listens to `longTokens` and `shortTokens` from user selection.
+ * - Uses `fetchHistoricalPriceData` to retrieve token candles for the range.
+ * - Computes and returns weighted basket candles via `computeBasketCandles`.
+ */
+export declare const useBasketCandles: () => UseBasketCandlesReturn;

package/dist/hooks/useHistoricalPriceData.d.ts

@@ -0,0 +1,9 @@
+import type { CandleData } from '../types';
+export interface UseHistoricalPriceDataReturn {
+    fetchHistoricalPriceData: (startTime: number, endTime: number, callback?: (data: Record<string, CandleData[]>) => void) => Promise<Record<string, CandleData[]>>;
+    hasHistoricalPriceData: (startTime: number, endTime: number) => boolean;
+    getHistoricalPriceData: (startTime: number, endTime: number) => Record<string, CandleData[]>;
+    isLoading: (symbol?: string) => boolean;
+    clearCache: () => void;
+}
+export declare const useHistoricalPriceData: () => UseHistoricalPriceDataReturn;

package/dist/hooks/useTokenSelectionMetadata.d.ts

@@ -0,0 +1,14 @@
+import { TokenMetadata } from "../types";
+export interface UseTokenSelectionMetadataReturn {
+    isLoading: boolean;
+    isPriceDataReady: boolean;
+    longTokensMetadata: Record<string, TokenMetadata | null>;
+    shortTokensMetadata: Record<string, TokenMetadata | null>;
+    weightedRatio: number;
+    weightedRatio24h: number;
+    sumNetFunding: number;
+    maxLeverage: number;
+    minMargin: number;
+    leverageMatched: boolean;
+}
+export declare const useTokenSelectionMetadata: () => UseTokenSelectionMetadataReturn;

package/dist/hooks/useTrading.d.ts

@@ -1,22 +1,22 @@
-/**
- * Hook to access trade histories with loading state
- */
 export declare const useTradeHistories: () => {
-    data: import("..").TradeHistoryDataDto[] | null;
+    data: any;
     isLoading: boolean;
 };
 /**
  * Hook to access open positions with real-time calculations and loading state
  */
 export declare const useOpenPositions: () => {
-    data: import("..").OpenPositionDto[] | null;
+    data: null;
+    isLoading: boolean;
+} | {
+    data: import("..").OpenPositionDto[];
     isLoading: boolean;
 };
 /**
  * Hook to access open orders with loading state
  */
 export declare const useOpenOrders: () => {
-    data: import("..").OpenLimitOrderDto[] | null;
+    data: any;
     isLoading: boolean;
 };
 /**

package/dist/hooks/useUserSelection.d.ts

@@ -0,0 +1,2 @@
+export declare const useUserSelection: any;
+export type { UserSelectionState } from "../store/userSelection";

package/dist/hooks/useWebData.d.ts

@@ -0,0 +1,12 @@
+import type { AssetMarketData } from '../types';
+/**
+ * Hook to access webData and native WebSocket state
+ */
+export declare const useWebData: () => {
+    clearinghouseState: any;
+    perpsAtOpenInterestCap: any;
+    marketDataBySymbol: Record<string, AssetMarketData>;
+    isConnected: boolean;
+    connectionStatus: import("react-use-websocket").ReadyState;
+    error: string | null;
+};

package/dist/hyperliquid-websocket.d.ts

@@ -1,13 +1,13 @@
 import { ReadyState } from 'react-use-websocket';
-import type { WebData2Response, WsAllMidsData } from './types';
+import type { CandleInterval } from './types';
 export interface UseHyperliquidNativeWebSocketProps {
     address: string | null;
+    tokens?: string[];
+    candleInterval?: CandleInterval;
 }
 export interface UseHyperliquidNativeWebSocketReturn {
-    webData2: WebData2Response | null;
-    allMids: WsAllMidsData | null;
     connectionStatus: ReadyState;
     isConnected: boolean;
     lastError: string | null;
 }
-export declare const useHyperliquidNativeWebSocket: ({ address }: UseHyperliquidNativeWebSocketProps) => UseHyperliquidNativeWebSocketReturn;
+export declare const useHyperliquidNativeWebSocket: ({ address, tokens, candleInterval }: UseHyperliquidNativeWebSocketProps) => UseHyperliquidNativeWebSocketReturn;

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import React, { ReactNode } from 'react';
+import * as react_use_websocket from 'react-use-websocket';
 import { ReadyState } from 'react-use-websocket';
 
 /**
@@ -215,7 +216,7 @@ type WebSocketConnectionState = 'connecting' | 'connected' | 'disconnected' | 'e
 /**
  * WebSocket channels
  */
-type WebSocketChannel = 'trade-histories' | 'open-positions' | 'open-orders' | 'account-summary' | 'webData2' | 'allMids';
+type WebSocketChannel = 'trade-histories' | 'open-positions' | 'open-orders' | 'account-summary' | 'webData2' | 'allMids' | 'activeAssetData';
 /**
  * WebSocket subscription message
  */
@@ -446,7 +447,8 @@ interface UniverseAsset {
     name: string;
     szDecimals: number;
     maxLeverage: number;
-    onlyIsolated: boolean;
+    onlyIsolated?: boolean;
+    isDelisted?: boolean;
 }
 /**
  * WebData2 response structure
@@ -519,28 +521,22 @@ interface AssetInformationDetail {
     assetIndex: number;
 }
 /**
- * Raw asset data from open-positions channel
+ * Leverage information from activeAssetData
  */
-interface RawAssetDto {
-    coin: string;
-    entryPrice: number;
-    size: number;
-    side: string;
+interface LeverageInfo {
+    type: string;
+    value: number;
 }
 /**
- * Raw position data from open-positions channel
+ * Active asset data from WebSocket
  */
-interface RawPositionDto {
-    positionId: string;
-    address: string;
-    leverage: number;
-    stopLoss: number | null;
-    takeProfit: number | null;
-    status: string;
-    createdAt: string;
-    updatedAt: string;
-    longAssets: RawAssetDto[];
-    shortAssets: RawAssetDto[];
+interface ActiveAssetData {
+    user: string;
+    coin: string;
+    leverage: LeverageInfo;
+    maxTradeSzs: [string, string];
+    availableToTrade: [string, string];
+    markPx: string;
 }
 /**
  * Token metadata from WebData2 and AllMids
@@ -556,6 +552,9 @@ interface TokenMetadata {
     oraclePrice: number;
     openInterest: string;
     dayVolume: string;
+    leverage?: LeverageInfo;
+    maxTradeSzs?: [string, string];
+    availableToTrade?: [string, string];
 }
 /**
  * Enhanced token selection with weight and metadata for basket trading
@@ -563,7 +562,6 @@ interface TokenMetadata {
 interface TokenSelection {
     symbol: string;
     weight: number;
-    metadata?: TokenMetadata;
 }
 /**
  * Token conflict information for position conflicts
@@ -573,6 +571,59 @@ interface TokenConflict {
     conflictType: 'long' | 'short';
     conflictMessage: string;
 }
+interface AssetMarketData {
+    asset: AssetCtx;
+    universe: UniverseAsset;
+}
+/**
+ * Candle interval options
+ */
+type CandleInterval = "1m" | "3m" | "5m" | "15m" | "30m" | "1h" | "2h" | "4h" | "8h" | "12h" | "1d" | "3d" | "1w" | "1M";
+/**
+ * Candle data structure from WebSocket
+ */
+interface CandleData {
+    t: number;
+    T: number;
+    s: string;
+    i: string;
+    o: string;
+    c: string;
+    h: string;
+    l: string;
+    v: string;
+    n: number;
+}
+/**
+ * Candle chart data organized by symbol only
+ * Since new candles always have latest timestamp, no need to store per interval
+ */
+type CandleChartData = Record<string, CandleData>;
+/**
+ * Historical candle data request
+ */
+interface CandleSnapshotRequest {
+    req: {
+        coin: string;
+        startTime: number;
+        endTime: number;
+        interval: CandleInterval;
+    };
+    type: "candleSnapshot";
+}
+/**
+ * Weighted candle data for chart visualization
+ */
+interface WeightedCandleData {
+    t: number;
+    T: number;
+    o: number;
+    c: number;
+    h: number;
+    l: number;
+    v: number;
+    n: number;
+}
 
 /**
  * Main SDK client for Pear Protocol Hyperliquid API integration
@@ -615,6 +666,15 @@ declare class PearHyperliquidClient {
      * @returns Promise with sync result
      */
     syncOpenOrders(payload: SyncOpenOrderDto): Promise<ApiResponse<SyncOpenOrderResponseDto>>;
+    /**
+     * Fetch historical candle data from HyperLiquid API
+     * @param coin - Token symbol (e.g., 'BTC', 'ETH')
+     * @param startTime - Start time in milliseconds
+     * @param endTime - End time in milliseconds
+     * @param interval - Candle interval
+     * @returns Promise with historical candle data
+     */
+    fetchHistoricalCandles(coin: string, startTime: number, endTime: number, interval: string): Promise<ApiResponse<CandleData[]>>;
 }
 
 /**
@@ -711,25 +771,25 @@ declare const useAddress: () => {
     isLoggedIn: boolean;
 };
 
-/**
- * Hook to access trade histories with loading state
- */
 declare const useTradeHistories: () => {
-    data: TradeHistoryDataDto[] | null;
+    data: any;
     isLoading: boolean;
 };
 /**
  * Hook to access open positions with real-time calculations and loading state
  */
 declare const useOpenPositions: () => {
-    data: OpenPositionDto[] | null;
+    data: null;
+    isLoading: boolean;
+} | {
+    data: OpenPositionDto[];
     isLoading: boolean;
 };
 /**
  * Hook to access open orders with loading state
  */
 declare const useOpenOrders: () => {
-    data: OpenLimitOrderDto[] | null;
+    data: any;
     isLoading: boolean;
 };
 /**
@@ -740,76 +800,98 @@ declare const useAccountSummary: () => {
     isLoading: boolean;
 };
 
-/**
- * Hook that calculates open positions by syncing platform positions with HyperLiquid real-time data
- */
-declare const useCalculatedOpenPositions: (platformPositions: RawPositionDto[] | null, webData2: WebData2Response | null, allMids: WsAllMidsData | null) => OpenPositionDto[] | null;
-
-/**
- * Hook that calculates account summary by syncing platform data with HyperLiquid real-time data
- */
-declare const useCalculatedAccountSummary: (platformAccountSummary: AccountSummaryResponseDto | null, platformOpenOrders: OpenLimitOrderDto[] | null, webData2: WebData2Response | null, agentWalletAddress?: string, agentWalletStatus?: string) => AccountSummaryResponseDto | null;
-
-interface UseTokenSelectionReturn {
+interface UserSelectionState {
     longTokens: TokenSelection[];
     shortTokens: TokenSelection[];
     openTokenSelector: boolean;
     selectorConfig: TokenSelectorConfig | null;
     openConflictModal: boolean;
     conflicts: TokenConflict[];
-    isLoading: boolean;
-    isPriceDataReady: boolean;
-    weightedRatio: number;
-    weightedRatio24h: number;
-    sumNetFunding: number;
-    maxLeverage: number;
-    minMargin: number;
+    candleInterval: CandleInterval;
     setLongTokens: (tokens: TokenSelection[]) => void;
     setShortTokens: (tokens: TokenSelection[]) => void;
-    updateTokenWeight: (isLong: boolean, index: number, newWeight: number) => void;
-    addToken: (isLong: boolean) => void;
-    removeToken: (isLong: boolean, index: number) => void;
-    handleTokenSelect: (selectedToken: string) => void;
     setOpenTokenSelector: (open: boolean) => void;
     setSelectorConfig: (config: TokenSelectorConfig | null) => void;
     setOpenConflictModal: (open: boolean) => void;
     setConflicts: (conflicts: TokenConflict[]) => void;
+    setCandleInterval: (interval: CandleInterval) => void;
+    updateTokenWeight: (isLong: boolean, index: number, newWeight: number) => void;
+    addToken: (isLong: boolean) => void;
+    removeToken: (isLong: boolean, index: number) => void;
+    handleTokenSelect: (selectedToken: string) => void;
     resetToDefaults: () => void;
 }
+
+declare const useUserSelection: any;
+
 /**
- * Hook to access token selection state using provider's WebSocket data
+ * Hook to access webData and native WebSocket state
  */
-declare const useTokenSelection: () => UseTokenSelectionReturn;
+declare const useWebData: () => {
+    clearinghouseState: any;
+    perpsAtOpenInterestCap: any;
+    marketDataBySymbol: Record<string, AssetMarketData>;
+    isConnected: boolean;
+    connectionStatus: react_use_websocket.ReadyState;
+    error: string | null;
+};
+
+interface UseTokenSelectionMetadataReturn {
+    isLoading: boolean;
+    isPriceDataReady: boolean;
+    longTokensMetadata: Record<string, TokenMetadata | null>;
+    shortTokensMetadata: Record<string, TokenMetadata | null>;
+    weightedRatio: number;
+    weightedRatio24h: number;
+    sumNetFunding: number;
+    maxLeverage: number;
+    minMargin: number;
+    leverageMatched: boolean;
+}
+declare const useTokenSelectionMetadata: () => UseTokenSelectionMetadataReturn;
 
-interface WebSocketData {
-    tradeHistories: TradeHistoryDataDto[] | null;
-    openPositions: RawPositionDto[] | null;
-    openOrders: OpenLimitOrderDto[] | null;
-    accountSummary: AccountSummaryResponseDto | null;
+interface UseHistoricalPriceDataReturn {
+    fetchHistoricalPriceData: (startTime: number, endTime: number, callback?: (data: Record<string, CandleData[]>) => void) => Promise<Record<string, CandleData[]>>;
+    hasHistoricalPriceData: (startTime: number, endTime: number) => boolean;
+    getHistoricalPriceData: (startTime: number, endTime: number) => Record<string, CandleData[]>;
+    isLoading: (symbol?: string) => boolean;
+    clearCache: () => void;
+}
+declare const useHistoricalPriceData: () => UseHistoricalPriceDataReturn;
+
+interface UseBasketCandlesReturn {
+    fetchBasketCandles: (startTime: number, endTime: number) => Promise<WeightedCandleData[]>;
+    isLoading: boolean;
 }
+/**
+ * Composes historical price fetching with basket candle computation.
+ * - Listens to `longTokens` and `shortTokens` from user selection.
+ * - Uses `fetchHistoricalPriceData` to retrieve token candles for the range.
+ * - Computes and returns weighted basket candles via `computeBasketCandles`.
+ */
+declare const useBasketCandles: () => UseBasketCandlesReturn;
+
 interface UseHyperliquidWebSocketProps {
     wsUrl: string;
     address: string | null;
 }
-interface UseHyperliquidWebSocketReturn {
-    data: WebSocketData;
+declare const useHyperliquidWebSocket: ({ wsUrl, address }: UseHyperliquidWebSocketProps) => {
     connectionStatus: ReadyState;
     isConnected: boolean;
     lastError: string | null;
-}
-declare const useHyperliquidWebSocket: ({ wsUrl, address }: UseHyperliquidWebSocketProps) => UseHyperliquidWebSocketReturn;
+};
 
 interface UseHyperliquidNativeWebSocketProps {
     address: string | null;
+    tokens?: string[];
+    candleInterval?: CandleInterval;
 }
 interface UseHyperliquidNativeWebSocketReturn {
-    webData2: WebData2Response | null;
-    allMids: WsAllMidsData | null;
     connectionStatus: ReadyState;
     isConnected: boolean;
     lastError: string | null;
 }
-declare const useHyperliquidNativeWebSocket: ({ address }: UseHyperliquidNativeWebSocketProps) => UseHyperliquidNativeWebSocketReturn;
+declare const useHyperliquidNativeWebSocket: ({ address, tokens, candleInterval }: UseHyperliquidNativeWebSocketProps) => UseHyperliquidNativeWebSocketReturn;
 
 /**
  * Account summary calculation utility class
@@ -875,17 +957,19 @@ declare class TokenMetadataExtractor {
      * @param symbol - Token symbol
      * @param webData2 - WebData2 response containing asset context and universe data
      * @param allMids - AllMids data containing current prices
+     * @param activeAssetData - Optional active asset data containing leverage information
      * @returns TokenMetadata or null if token not found
      */
-    static extractTokenMetadata(symbol: string, webData2: WebData2Response | null, allMids: WsAllMidsData | null): TokenMetadata | null;
+    static extractTokenMetadata(symbol: string, webData2: WebData2Response | null, allMids: WsAllMidsData | null, activeAssetData?: Record<string, ActiveAssetData> | null): TokenMetadata | null;
     /**
      * Extracts metadata for multiple tokens
      * @param symbols - Array of token symbols
      * @param webData2 - WebData2 response
      * @param allMids - AllMids data
+     * @param activeAssetData - Optional active asset data containing leverage information
      * @returns Record of symbol to TokenMetadata
      */
-    static extractMultipleTokensMetadata(symbols: string[], webData2: WebData2Response | null, allMids: WsAllMidsData | null): Record<string, TokenMetadata | null>;
+    static extractMultipleTokensMetadata(symbols: string[], webData2: WebData2Response | null, allMids: WsAllMidsData | null, activeAssetData?: Record<string, ActiveAssetData> | null): Record<string, TokenMetadata | null>;
     /**
      * Checks if token data is available in WebData2
      * @param symbol - Token symbol
@@ -895,5 +979,42 @@ declare class TokenMetadataExtractor {
     static isTokenAvailable(symbol: string, webData2: WebData2Response | null): boolean;
 }
 
-export { AccountSummaryCalculator, ConflictDetector, PearHyperliquidClient, PearHyperliquidProvider, PearMigrationSDK, TokenMetadataExtractor, PearHyperliquidClient as default, useAccountSummary, useAddress, useCalculatedAccountSummary, useCalculatedOpenPositions, useHyperliquidNativeWebSocket, useHyperliquidWebSocket, useMigrationSDK, useOpenOrders, useOpenPositions, usePearHyperliquidClient, useTokenSelection, useTradeHistories };
-export type { AccountSummaryResponseDto, AgentWalletDto, ApiErrorResponse, ApiResponse, AssetCtx, AssetInformationDetail, AssetPosition, BalanceSummaryDto, CrossMarginSummaryDto, CumFundingDto, MarginSummaryDto, MigrationHookState, MigrationHooks, OpenLimitOrderDto, OpenOrderV1Dto, OpenPositionDto, OpenPositionV1Dto, OrderAssetDto, OrderStatus, PearHyperliquidConfig, PnlDto, PositionAssetDetailDto, PositionSideDto, PositionSyncStatus, RawValueDto, SyncOpenOrderDto, SyncOpenOrderResponseDto, SyncOpenPositionDto, SyncOpenPositionResponseDto, SyncTradeHistoryDto, SyncTradeHistoryResponseDto, TokenConflict, TokenMetadata, TokenSelection, TokenSelectorConfig, TpSlDto, TradeHistoryAssetDataDto, TradeHistoryDataDto, TradeHistoryV1Dto, UniverseAsset, UseTokenSelectionReturn, WebData2Response, WebSocketChannel, WebSocketConnectionState, WebSocketDataMessage, WebSocketMessage, WebSocketResponse, WebSocketSubscribeMessage, WsAllMidsData };
+/**
+ * Create efficient timestamp-based lookup maps for candle data
+ */
+declare const createCandleLookups: (tokenCandles: Record<string, CandleData[]>) => Record<string, Map<number, CandleData>>;
+/**
+ * Calculate weighted ratio for a specific price type (open, high, low, close)
+ * Uses the formula: LONG_PRODUCT * SHORT_PRODUCT
+ * Where LONG_PRODUCT = ∏(PRICE^(WEIGHT/100)) for long tokens
+ * And SHORT_PRODUCT = ∏(PRICE^-(WEIGHT/100)) for short tokens
+ *
+ * Optimized version that uses Map lookups instead of Array.find()
+ */
+declare const calculateWeightedRatio: (longTokens: TokenSelection[], shortTokens: TokenSelection[], candleLookups: Record<string, Map<number, CandleData>>, timestamp: number, priceType: "o" | "h" | "l" | "c") => number;
+/**
+ * Get all unique timestamps where ALL required symbols have data
+ * Optimized version that uses Map lookups
+ */
+declare const getCompleteTimestamps: (candleLookups: Record<string, Map<number, CandleData>>, requiredSymbols: string[]) => number[];
+/**
+ * Compute basket candles from individual token candles using weighted ratios
+ * Optimized version that creates lookup maps once and reuses them
+ */
+declare const computeBasketCandles: (longTokens: TokenSelection[], shortTokens: TokenSelection[], tokenCandles: Record<string, CandleData[]>) => WeightedCandleData[];
+
+interface HistoricalRange {
+    start: number;
+    end: number;
+}
+interface TokenHistoricalPriceData {
+    symbol: string;
+    interval: CandleInterval;
+    candles: CandleData[];
+    oldestTime: number | null;
+    latestTime: number | null;
+}
+declare const useHistoricalPriceDataStore: any;
+
+export { AccountSummaryCalculator, ConflictDetector, PearHyperliquidClient, PearHyperliquidProvider, PearMigrationSDK, TokenMetadataExtractor, calculateWeightedRatio, computeBasketCandles, createCandleLookups, PearHyperliquidClient as default, getCompleteTimestamps, useAccountSummary, useAddress, useBasketCandles, useHistoricalPriceData, useHistoricalPriceDataStore, useHyperliquidNativeWebSocket, useHyperliquidWebSocket, useMigrationSDK, useOpenOrders, useOpenPositions, usePearHyperliquidClient, useTokenSelectionMetadata, useTradeHistories, useUserSelection, useWebData };
+export type { AccountSummaryResponseDto, AgentWalletDto, ApiErrorResponse, ApiResponse, AssetCtx, AssetInformationDetail, AssetPosition, BalanceSummaryDto, CandleChartData, CandleData, CandleInterval, CandleSnapshotRequest, CrossMarginSummaryDto, CumFundingDto, HistoricalRange, MarginSummaryDto, MigrationHookState, MigrationHooks, OpenLimitOrderDto, OpenOrderV1Dto, OpenPositionDto, OpenPositionV1Dto, OrderAssetDto, OrderStatus, PearHyperliquidConfig, PnlDto, PositionAssetDetailDto, PositionSideDto, PositionSyncStatus, RawValueDto, SyncOpenOrderDto, SyncOpenOrderResponseDto, SyncOpenPositionDto, SyncOpenPositionResponseDto, SyncTradeHistoryDto, SyncTradeHistoryResponseDto, TokenConflict, TokenHistoricalPriceData, TokenMetadata, TokenSelection, TpSlDto, TradeHistoryAssetDataDto, TradeHistoryDataDto, TradeHistoryV1Dto, UniverseAsset, UseBasketCandlesReturn, UseHistoricalPriceDataReturn, UseTokenSelectionMetadataReturn, UserSelectionState, WebData2Response, WebSocketChannel, WebSocketConnectionState, WebSocketDataMessage, WebSocketMessage, WebSocketResponse, WebSocketSubscribeMessage, WeightedCandleData, WsAllMidsData };