@liberfi.io/ui-predict 0.1.0 → 0.1.1

package/dist/index.d.mts

@@ -1,10 +1,10 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import { E as Event, M as Market, a as EventQueryOptions, P as PriceHistory, b as PriceHistoryInterval, I as IPredictClient, c as MarketQueryOptions, d as MarketTag, S as SearchQueryOptions, e as SearchResult, f as MarketPriceQuery, g as MarketPrice, h as MultipleMarketPrices, i as MarketPriceRequestItem, j as PriceHistoryQuery } from './index-CT0nyuNQ.mjs';
-export { C as Chat, t as EventCreator, k as ImageOptimized, m as MarketCategory, l as MarketEvent, s as PriceHistoryPoint, n as PriceSide, o as SearchEvent, r as SearchPagination, q as SearchProfile, p as SearchTag, u as Template, T as TokenPriceData } from './index-CT0nyuNQ.mjs';
+import { S as StandardEvent, a as StandardMarket, E as EventQueryParams, O as OrderResponse, b as SeriesResponse, C as CandlesticksResponse, c as OrderbookLevel, d as SingleTradeResponse, I as IPredictClient, e as IPredictWsClient, f as StandardEventsResponse, M as MarketQueryParams, g as StandardMarketsResponse, h as MarketsBatchRequest, i as OrderbookResponse, T as TradesQueryParams, j as MultiTradeResponse, k as TradesByMintQueryParams, l as CandlesticksQueryParams, F as ForecastPercentileHistoryQueryParams, m as ForecastPercentileHistoryResponse, n as ForecastPercentileHistoryByMintQueryParams, L as LiveDataQueryParams, o as LiveDataResponse, p as LiveDataByEventQueryParams, q as LiveDataByMintQueryParams, r as SeriesQueryParams, s as SeriesListResponse, t as TagsByCategoriesResponse, u as FiltersBySportsResponse, v as SearchQueryParams, w as SearchResponse, x as OutcomeMintsQueryParams, y as OutcomeMintsResponse, z as FilterOutcomeMintsRequest, A as FilterOutcomeMintsResponse, Q as QuoteQueryParams, B as QuoteResponse, D as SwapRequestBody, G as SwapResponse, H as SwapInstructionsResponse, J as OrderQueryParams, K as OrderStatusQueryParams, N as OrderStatusResponse, P as IntentQuoteQueryParams, R as IntentQuoteResponse, U as IntentSwapRequestBody, V as IntentSwapResponse, W as PredictionMarketInitQueryParams, X as PredictionMarketInitResponse, Y as TokenListResponse, Z as TokenListWithDecimalsResponse, _ as VenueListResponse, $ as WsConnectionStatus, a0 as WsPriceUpdate, a1 as WsTradeUpdate, a2 as WsOrderbookUpdate } from './index-BcVbsRbS.mjs';
+export { am as AccountMetaResponse, az as BasePredictClient, ao as BlockhashWithMetadata, af as CandlestickDataPoint, ae as CandlestickOHLC, ak as ComputeBudgetInfo, aw as CreateFeeAccountParams, av as DestinationTokenAccountParam, aC as DflowPredictClient, aD as DflowPredictWsClient, ab as ExecutionMode, ag as ForecastPercentileDataPoint, an as InstructionResponse, ar as IntentExpiry, ad as MarketAccountInfo, a4 as MarketStatus, ap as OrderFill, aq as OrderRevert, a7 as OrderStatus, at as OrderbookQueryParams, aj as PlatformFee, a8 as PlatformFeeMode, ax as PositiveSlippageParams, aC as PredictClient, aD as PredictWsClient, au as PrioritizationFeeLamports, al as PrioritizationType, aa as PriorityLevel, a3 as ProviderType, ai as RoutePlanLeg, ah as SeriesSettlementSource, ac as SettlementSource, a9 as SlippageTolerance, a5 as SortField, a6 as SortOrder, as as TokenWithDecimals, aF as WsClientConfig, ay as WsSubscribeOptions, aA as buildQuery, aE as createDflowPredictWsClient, aE as createPredictWsClient, aB as toRecord } from './index-BcVbsRbS.mjs';
 import * as react from 'react';
 import { PropsWithChildren } from 'react';
 import * as _tanstack_react_query from '@tanstack/react-query';
-import { UseQueryOptions } from '@tanstack/react-query';
+import { UseQueryOptions, UseInfiniteQueryOptions, InfiniteData, UseMutationOptions } from '@tanstack/react-query';
 
 declare global {
     interface Window {
@@ -13,86 +13,77 @@ declare global {
         };
     }
 }
-declare const _default: "0.1.0";
+declare const _default: "0.1.1";
 
 interface EventsWidgetProps {
     /** Callback when an event is selected */
-    onSelect?: (event: Event) => void;
+    onSelect?: (event: StandardEvent) => void;
     /** Callback when an outcome (yes/no) is selected */
-    onSelectOutcome?: (event: Event, market: Market, side: "yes" | "no") => void;
+    onSelectOutcome?: (event: StandardEvent, market: StandardMarket, side: "yes" | "no") => void;
 }
 declare function EventsWidget({ onSelect, onSelectOutcome }: EventsWidgetProps): react_jsx_runtime.JSX.Element;
 
 /**
- * useEvents parameters
+ * useEvents parameters — same as EventQueryParams but without cursor (managed internally)
  */
-interface UseEventsParams {
-    /** Initial page number, defaults to 1 */
-    initialPage?: number;
-    /** Number of items per page, defaults to 48 */
-    pageSize?: number;
-    /** Query options (excluding limit and offset) */
-    queryOptions?: Omit<EventQueryOptions, "limit" | "offset">;
-}
+type UseEventsParams = Omit<EventQueryParams, "cursor">;
 /**
  * useEvents return value
  */
 interface UseEventsResult {
-    /** Events list data */
-    data: Event[];
-    /** Whether data is loading */
+    /** All accumulated events data */
+    data: StandardEvent[];
+    /** Whether initial data is loading */
     isLoading: boolean;
-    /** Whether data is being fetched (including background refresh) */
-    isFetching: boolean;
+    /** Whether more data is being fetched */
+    isFetchingMore: boolean;
     /** Whether there is an error */
     isError: boolean;
     /** Error information */
     error: Error | null;
-    /** Current page number (starts from 1) */
-    page: number;
-    /** Number of items per page */
-    pageSize: number;
-    /** Whether there is a next page */
-    hasNextPage: boolean;
-    /** Whether there is a previous page */
-    hasPrevPage: boolean;
-    /** Navigate to a specific page */
-    goToPage: (page: number) => void;
-    /** Go to next page */
-    nextPage: () => void;
-    /** Go to previous page */
-    prevPage: () => void;
-    /** Update query options */
-    setQueryOptions: (options: Omit<EventQueryOptions, "limit" | "offset">) => void;
-    /** Refetch data */
+    /** Whether there is more data to load */
+    hasMore: boolean;
+    /** Fetch more results */
+    fetchMore: () => void;
+    /** Update query options (resets accumulated data) */
+    setQueryOptions: (options: UseEventsParams) => void;
+    /** Refetch all pages */
     refetch: () => void;
 }
 /**
- * Events list hook with pagination and query options support
+ * Events list hook with infinite scroll support (cursor-based pagination)
  *
  * @example
  * ```tsx
  * const {
  *   data,
  *   isLoading,
- *   page,
- *   hasNextPage,
- *   nextPage,
+ *   hasMore,
+ *   isFetchingMore,
+ *   fetchMore,
  *   setQueryOptions
  * } = useEvents({
- *   pageSize: 20,
- *   queryOptions: { category: 'sports' }
+ *   limit: 20,
+ *   status: 'active',
+ *   withNestedMarkets: true
  * });
  * ```
  */
-declare function useEvents({ initialPage, pageSize, queryOptions: initialQueryOptions, }?: UseEventsParams): UseEventsResult;
+declare function useEvents(initialParams?: UseEventsParams): UseEventsResult;
 
 type EventsUIProps = {
-    events: Event[];
-    onSelect?: (event: Event) => void;
-    onSelectOutcome?: (event: Event, market: Market, side: "yes" | "no") => void;
+    /** Events data to render */
+    events: StandardEvent[];
+    /** Whether there is more data to load */
+    hasMore?: boolean;
+    /** Callback to fetch more data */
+    onFetchMore?: () => void;
+    /** Callback when an event is selected */
+    onSelect?: (event: StandardEvent) => void;
+    /** Callback when an outcome (yes/no) is selected */
+    onSelectOutcome?: (event: StandardEvent, market: StandardMarket, side: "yes" | "no") => void;
 };
-declare function EventsUI({ events, onSelect, onSelectOutcome }: EventsUIProps): react_jsx_runtime.JSX.Element;
+declare function EventsUI({ events, hasMore, onFetchMore, onSelect, onSelectOutcome, }: EventsUIProps): react_jsx_runtime.JSX.Element;
 
 type EventItemSkeletonProps = {
     className?: string;
@@ -104,139 +95,849 @@ type EventsSkeletonProps = {
 declare function EventsSkeleton({ count }: EventsSkeletonProps): react_jsx_runtime.JSX.Element;
 
 type EventItemUIProps = {
-    event: Event;
-    onSelect?: (event: Event) => void;
-    onSelectOutcome?: (event: Event, market: Market, side: "yes" | "no") => void;
+    event: StandardEvent;
+    onSelect?: (event: StandardEvent) => void;
+    onSelectOutcome?: (event: StandardEvent, market: StandardMarket, side: "yes" | "no") => void;
 };
 declare function EventItemUI({ event, onSelect, onSelectOutcome, }: EventItemUIProps): react_jsx_runtime.JSX.Element;
 
-interface EventDetailUIProps {
-    event: Event;
-    /** Map of marketId to price history data */
-    priceHistories?: Map<string, PriceHistory>;
-    /** Interval for price history query */
-    priceHistoryInterval?: PriceHistoryInterval;
-    /** Whether price history is loading */
-    isPriceHistoryLoading?: boolean;
-    /** Map of marketId to price history error */
-    priceHistoryErrors?: Map<string, Error>;
-    /** Callback when interval changes */
-    onIntervalChange?: (interval: PriceHistoryInterval) => void;
-    /** Selected market IDs for price history chart */
-    selectedMarketIds?: string[];
-    /** Callback when selected markets change */
-    onMarketSelectionChange?: (marketIds: string[]) => void;
+/** Default page size for list queries */
+declare const DEFAULT_PAGE_SIZE = 48;
+/** Maximum number of markets to display in price history chart */
+declare const MAX_PRICE_HISTORY_MARKETS = 4;
+/**
+ * Candlestick period intervals in minutes (granularity for API queries)
+ */
+declare const CandlestickPeriod: {
+    /** 1 minute */
+    readonly ONE_MINUTE: 1;
+    /** 1 hour (60 minutes) */
+    readonly ONE_HOUR: 60;
+    /** 1 day (1440 minutes) */
+    readonly ONE_DAY: 1440;
+};
+type CandlestickPeriodType = (typeof CandlestickPeriod)[keyof typeof CandlestickPeriod];
+/**
+ * Chart range options (the user-facing time range selector)
+ */
+declare const ChartRange: {
+    /** 1 day */
+    readonly ONE_DAY: "1d";
+    /** 1 week */
+    readonly ONE_WEEK: "1w";
+    /** 1 month */
+    readonly ONE_MONTH: "1m";
+    /** All time */
+    readonly ALL: "all";
+};
+type ChartRangeType = (typeof ChartRange)[keyof typeof ChartRange];
+/** Default chart range */
+declare const DEFAULT_CHART_RANGE: "all";
+/** Candlestick granularity derived from chart range (1D → minute, 1W/1M → hourly, ALL → daily) */
+declare const CHART_RANGE_PERIOD: Record<ChartRangeType, CandlestickPeriodType>;
+/** Chart sampling interval in seconds (used to downsample candlestick data for display) */
+declare const CHART_RANGE_SAMPLE_INTERVAL: Record<ChartRangeType, number>;
+/** Duration in seconds for each chart range (null = all time) */
+declare const CHART_RANGE_DURATION: Record<ChartRangeType, number | null>;
+/** Minimum order quantity (contracts) */
+declare const ORDER_MIN_QUANTITY = 1;
+/** Price step size in cents */
+declare const ORDER_PRICE_STEP = 1;
+/** Minimum price in cents */
+declare const ORDER_MIN_PRICE = 1;
+/** Maximum price in cents */
+declare const ORDER_MAX_PRICE = 99;
+/** @deprecated Use ChartRange instead */
+declare const PriceHistoryInterval: {
+    readonly ONE_HOUR: "1h";
+    readonly SIX_HOURS: "6h";
+    readonly ONE_DAY: "1d";
+    readonly ONE_WEEK: "1w";
+    readonly MAX: "max";
+};
+/** @deprecated Use ChartRangeType instead */
+type PriceHistoryIntervalType = (typeof PriceHistoryInterval)[keyof typeof PriceHistoryInterval];
+/** @deprecated Use DEFAULT_CHART_RANGE instead */
+declare const DEFAULT_PRICE_HISTORY_INTERVAL: "1w";
+/** @deprecated */
+declare const PRICE_HISTORY_SAMPLE_INTERVAL: Record<PriceHistoryIntervalType, number>;
+
+/** Trade outcome - yes or no */
+type TradeOutcome = "yes" | "no";
+/** Trade side - buy or sell */
+type TradeSide = "buy" | "sell";
+interface UseTradeFormParams {
+    /** Market to trade in */
+    market: StandardMarket;
+    /** Chain network to use (default: 'solana') */
+    chain?: string;
+    /** Initial trade outcome */
+    initialOutcome?: TradeOutcome;
+    /** Initial trade side */
+    initialSide?: TradeSide;
+}
+interface TradeFormValidation {
+    isValid: boolean;
+    errors: string[];
 }
-declare function EventDetailUI({ event, priceHistories, priceHistoryInterval, isPriceHistoryLoading, priceHistoryErrors, onIntervalChange, selectedMarketIds, onMarketSelectionChange, }: EventDetailUIProps): react_jsx_runtime.JSX.Element;
+interface UseTradeFormResult {
+    /** Current outcome (yes/no) */
+    outcome: TradeOutcome;
+    /** Current side (buy/sell) */
+    side: TradeSide;
+    /** Number of contracts */
+    quantity: number;
+    /** Number of shares (buy: amount / price, sell: quantity) */
+    shares: number;
+    /** Estimated cost in dollars */
+    estimatedCost: number;
+    /** Potential payout in dollars */
+    potentialPayout: number;
+    /** Potential profit in dollars */
+    potentialProfit: number;
+    /** Whether the user is authenticated */
+    isAuthenticated: boolean;
+    /** Best bid price from order book (cents) */
+    bestBid: number | null;
+    /** Best ask price from order book (cents) */
+    bestAsk: number | null;
+    /** Current order response from the API (includes quote + transaction) */
+    order: OrderResponse | null;
+    /** Price impact percentage */
+    priceImpact: number | null;
+    /** USDC balance in dollars (for buy side) */
+    usdcBalance: number | null;
+    /** Outcome token balance in token units (for sell side) */
+    outcomeTokenBalance: number | null;
+    /** Yes token balance (shares held) */
+    yesTokenBalance: number | null;
+    /** No token balance (shares held) */
+    noTokenBalance: number | null;
+    /** Whether balance is being fetched */
+    isBalanceLoading: boolean;
+    /** Whether order/quote is being fetched */
+    isQuoteLoading: boolean;
+    /** Whether a transaction is being signed/sent */
+    isSubmitting: boolean;
+    /** Order/quote fetch error (if any) */
+    quoteError: Error | null;
+    /** Transaction hash after successful send */
+    txHash: string | null;
+    /** Form validation result */
+    validation: TradeFormValidation;
+    /** Set outcome */
+    setOutcome: (outcome: TradeOutcome) => void;
+    /** Set side */
+    setSide: (side: TradeSide) => void;
+    /** Set quantity (minimum ORDER_MIN_QUANTITY) */
+    setQuantity: (quantity: number) => void;
+    /** Submit the swap */
+    submit: () => void;
+    /** Reset form to initial values */
+    reset: () => void;
+}
+declare function useTradeForm({ market, chain: _chain, initialOutcome, initialSide, }: UseTradeFormParams): UseTradeFormResult;
 
 interface EventDetailWidgetProps {
     eventId: string;
-    /** Initial market IDs to query price history for. Default is first 4 markets of the event, max is 4. */
-    initialMarketIds?: string[];
-    /** Initial interval for price history. Default is ONE_WEEK. */
-    initialInterval?: PriceHistoryInterval;
+    /** Initial market tickers to query candlesticks for. Default is first 4 markets of the event, max is 4. */
+    initialMarketTickers?: string[];
+    /** Initial chart range. Default is "1d" (1 day). */
+    initialChartRange?: ChartRangeType;
+    /** Callback when a trade action is triggered (market button / orderbook click) */
+    onTradeAction?: (market: StandardMarket, outcome: TradeOutcome, side: TradeSide) => void;
 }
-declare function EventDetailWidget({ eventId, initialMarketIds, initialInterval, }: EventDetailWidgetProps): react_jsx_runtime.JSX.Element;
+declare function EventDetailWidget({ eventId, initialMarketTickers, initialChartRange, onTradeAction, }: EventDetailWidgetProps): react_jsx_runtime.JSX.Element;
+
+interface EventDetailPageProps extends Omit<EventDetailWidgetProps, "eventId" | "onTradeAction"> {
+    /** Event ticker ID */
+    eventId: string;
+    /** Chain network for trading (default: 'solana') */
+    chain?: string;
+}
+declare function EventDetailPage({ eventId, chain, ...widgetProps }: EventDetailPageProps): react_jsx_runtime.JSX.Element;
+
+interface EventDetailUIProps {
+    event: StandardEvent;
+    /** Series data for the event */
+    series?: SeriesResponse;
+    /** Map of market ticker to candlestick data */
+    candlesticks?: Map<string, CandlesticksResponse>;
+    /** Currently selected chart range */
+    chartRange?: ChartRangeType;
+    /** Derived candlestick period interval (for chart formatting) */
+    periodInterval?: CandlestickPeriodType;
+    /** Whether candlesticks are loading */
+    isCandlesticksLoading?: boolean;
+    /** Map of market ticker to candlestick error */
+    candlestickErrors?: Map<string, Error>;
+    /** Callback when chart range changes */
+    onRangeChange?: (range: ChartRangeType) => void;
+    /** Selected market tickers for candlestick chart */
+    selectedMarketTickers?: string[];
+    /** Callback when selected markets change */
+    onMarketSelectionChange?: (marketTickers: string[]) => void;
+    /** Callback when a trade action is triggered (market button / orderbook click) */
+    onTradeAction?: (market: StandardMarket, outcome: TradeOutcome, side: TradeSide) => void;
+}
+declare function EventDetailUI({ event, series, candlesticks, chartRange, periodInterval, isCandlesticksLoading, onRangeChange, selectedMarketTickers, onMarketSelectionChange, onTradeAction, }: EventDetailUIProps): react_jsx_runtime.JSX.Element;
 
 interface UseEventDetailParams {
     eventId: string;
-    /** Market IDs to query price history for. Default is first 4 markets of the event, max is 4. */
-    priceHistoryMarketIds?: string[];
-    /** Interval for price history query. Default is ONE_WEEK. */
-    priceHistoryInterval?: PriceHistoryInterval;
+    /** Market tickers to query candlesticks for. Default is first 4 markets of the event, max is 4. */
+    candlestickMarketTickers?: string[];
+    /** Chart time range (1d / 1w / 1m / all). Determines both the query window and candlestick granularity. */
+    chartRange?: ChartRangeType;
 }
 declare const useEventDetail: (params: UseEventDetailParams) => {
-    event: Event | undefined;
+    event: StandardEvent | undefined;
     isEventLoading: boolean;
     eventError: Error | null;
-    priceHistories: Map<string, PriceHistory>;
-    isPriceHistoryLoading: boolean;
-    priceHistoryErrors: Map<string, Error>;
+    series: SeriesResponse | undefined;
+    isSeriesLoading: boolean;
+    seriesError: Error | null;
+    /** Derived candlestick granularity (for chart formatting) */
+    periodInterval: CandlestickPeriodType;
+    candlesticks: Map<string, CandlesticksResponse>;
+    isCandlesticksLoading: boolean;
+    candlestickErrors: Map<string, Error>;
 };
 
 interface EventDetailSkeletonProps {
-    /** Number of market rows to show in table skeleton */
+    /** Number of market rows */
     marketCount?: number;
 }
 declare function EventDetailSkeleton({ marketCount, }: EventDetailSkeletonProps): react_jsx_runtime.JSX.Element;
+/** Compact skeleton for the sidebar trade form area */
+declare function TradeFormSkeleton(): react_jsx_runtime.JSX.Element;
+
+interface EventMarketDetailWidgetProps {
+    market: StandardMarket;
+    /** Callback when an orderbook row is clicked – propagates market, outcome & side */
+    onTradeAction?: (market: StandardMarket, outcome: TradeOutcome, side: TradeSide) => void;
+}
+declare function EventMarketDetailWidget({ market, onTradeAction, }: EventMarketDetailWidgetProps): react_jsx_runtime.JSX.Element;
+
+interface TradeFormUIProps {
+    /** Event data */
+    event?: StandardEvent;
+    /** Market data */
+    market: StandardMarket;
+    /** Current outcome */
+    outcome: TradeOutcome;
+    /** Current side */
+    side: TradeSide;
+    /** Number of contracts */
+    quantity: number;
+    /** Estimated cost in cents */
+    estimatedCost: number;
+    /** Potential payout in cents */
+    potentialPayout: number;
+    /** Potential profit in cents */
+    potentialProfit: number;
+    /** Whether swap is being submitted */
+    isSubmitting: boolean;
+    /** USDC balance in dollars (null if not loaded) */
+    usdcBalance: number | null;
+    /** Yes token balance (shares held, for sell side) */
+    yesTokenBalance: number | null;
+    /** No token balance (shares held, for sell side) */
+    noTokenBalance: number | null;
+    /** Whether balance is loading */
+    isBalanceLoading: boolean;
+    /** Whether the form is valid */
+    isValid: boolean;
+    /** Validation error messages */
+    validationErrors: string[];
+    /** Set outcome */
+    onOutcomeChange: (outcome: TradeOutcome) => void;
+    /** Set side */
+    onSideChange: (side: TradeSide) => void;
+    /** Set quantity */
+    onQuantityChange: (quantity: number) => void;
+    /** Submit swap */
+    onSubmit: () => void;
+}
+declare function TradeFormUI({ event, market, outcome, side, quantity, potentialProfit, estimatedCost, usdcBalance, yesTokenBalance, noTokenBalance, isBalanceLoading, isSubmitting, isValid, onOutcomeChange, onSideChange, onQuantityChange, onSubmit, }: TradeFormUIProps): react_jsx_runtime.JSX.Element;
+
+interface TradeFormWidgetProps {
+    /** Event data */
+    event?: StandardEvent;
+    /** Market to trade */
+    market: StandardMarket;
+    /** Initial trade side */
+    initialSide?: TradeSide;
+    /** Initial trade outcome */
+    initialOutcome?: TradeOutcome;
+    /** Chain network (default: 'solana') */
+    chain?: string;
+}
+declare function TradeFormWidget({ event, market, initialSide, initialOutcome, chain, }: TradeFormWidgetProps): react_jsx_runtime.JSX.Element;
+
+interface UseOrderBookParams {
+    /** Market ticker */
+    marketTicker: string;
+    /** Maximum number of levels to display per side */
+    maxLevels?: number;
+    /** Polling interval in milliseconds (0 to disable) */
+    refetchInterval?: number;
+    /** Which outcome to display (yes or no). Defaults to yes. */
+    outcome?: "yes" | "no";
+}
+interface OrderBookRow extends OrderbookLevel {
+    /** Cumulative quantity up to (and including) this level */
+    cumulative: number;
+    /** Depth ratio 0–1 relative to the maximum cumulative quantity */
+    depth: number;
+}
+interface UseOrderBookResult {
+    /** Bid rows sorted from highest to lowest price */
+    bids: OrderBookRow[];
+    /** Ask rows sorted from lowest to highest price */
+    asks: OrderBookRow[];
+    /** Spread in cents */
+    spread: number | null;
+    /** Spread as percentage of midpoint */
+    spreadPercent: number | null;
+    /** Midpoint price in cents */
+    midpoint: number | null;
+    /** Whether initial data is loading */
+    isLoading: boolean;
+    /** Whether a background refetch is in progress */
+    isFetching: boolean;
+}
+declare function useOrderBook({ marketTicker, maxLevels, refetchInterval, outcome, }: UseOrderBookParams): UseOrderBookResult;
+
+interface OrderBookUIProps {
+    /** Bid rows (highest to lowest) */
+    bids: OrderBookRow[];
+    /** Ask rows (lowest to highest) */
+    asks: OrderBookRow[];
+    /** Spread in cents */
+    spread: number | null;
+    /** Spread percentage */
+    spreadPercent: number | null;
+    /** Whether initial data is loading */
+    isLoading: boolean;
+    /** Callback when a price level is clicked */
+    onPriceClick?: (price: number) => void;
+}
+declare function OrderBookUI({ bids, asks, spread, spreadPercent, isLoading, onPriceClick, }: OrderBookUIProps): react_jsx_runtime.JSX.Element;
+
+interface OrderBookWidgetProps {
+    /** Market ticker */
+    marketTicker: string;
+    /** Maximum levels per side (default 10) */
+    maxLevels?: number;
+    /** Polling interval in ms (default 5000, 0 to disable) */
+    refetchInterval?: number;
+    /** Callback when a price level is clicked */
+    onPriceClick?: (price: number) => void;
+    /** Which outcome to display (yes or no). Defaults to yes. */
+    outcome?: "yes" | "no";
+}
+declare function OrderBookWidget({ marketTicker, maxLevels, refetchInterval, onPriceClick, outcome, }: OrderBookWidgetProps): react_jsx_runtime.JSX.Element;
+
+interface UseOpenOrdersParams {
+    /** Polling interval in ms (0 to disable) */
+    refetchInterval?: number;
+}
+/**
+ * @deprecated Order type - new API uses swap model
+ */
+interface Order {
+    id: string;
+    marketId: string;
+    side: "buy" | "sell";
+    outcome: "yes" | "no";
+    type: "limit" | "market";
+    price: number;
+    quantity: number;
+    filledQuantity: number;
+    status: "open" | "partial" | "filled" | "cancelled";
+    createdAt: string;
+}
+interface UseOpenOrdersResult {
+    /** List of open orders */
+    orders: Order[];
+    /** Whether data is loading */
+    isLoading: boolean;
+    /** Whether a background refetch is in progress */
+    isFetching: boolean;
+    /** ID of the order currently being cancelled (null if none) */
+    cancellingOrderId: string | null;
+    /** Cancel an order by id */
+    cancelOrder: (orderId: string) => void;
+    /** Error from the most recent cancel attempt */
+    cancelError: Error | null;
+}
+/**
+ * @deprecated This hook is deprecated. The new dflow API uses a swap-based model.
+ * Use `useOrderStatusQuery` to track swap status instead.
+ */
+declare function useOpenOrders(_params?: UseOpenOrdersParams): UseOpenOrdersResult;
+
+interface OpenOrdersUIProps {
+    /** List of open orders */
+    orders: Order[];
+    /** Whether data is loading */
+    isLoading: boolean;
+    /** ID of the order currently being cancelled */
+    cancellingOrderId: string | null;
+    /** Cancel an order */
+    onCancel: (orderId: string) => void;
+}
+declare function OpenOrdersUI({ orders, isLoading, cancellingOrderId, onCancel, }: OpenOrdersUIProps): react_jsx_runtime.JSX.Element;
+
+interface OpenOrdersWidgetProps {
+    /** Polling interval in ms (default 10000, 0 to disable) */
+    refetchInterval?: number;
+}
+/**
+ * @deprecated This widget is deprecated. Use swap-based order model instead.
+ */
+declare function OpenOrdersWidget({ refetchInterval, }?: OpenOrdersWidgetProps): react_jsx_runtime.JSX.Element;
+
+interface UseTradeHistoryParams {
+    /** Optional filter by market ticker */
+    ticker?: string;
+    /** Page size */
+    pageSize?: number;
+}
+interface UseTradeHistoryResult {
+    /** Current page of trades */
+    trades: SingleTradeResponse[];
+    /** Whether initial data is loading */
+    isLoading: boolean;
+    /** Whether a background refetch is in progress */
+    isFetching: boolean;
+    /** Current page (1-based) */
+    page: number;
+    /** Page size */
+    pageSize: number;
+    /** Whether more pages exist */
+    hasNextPage: boolean;
+    /** Whether a previous page exists */
+    hasPrevPage: boolean;
+    /** Navigate to a specific page */
+    goToPage: (page: number) => void;
+    /** Go to the next page */
+    nextPage: () => void;
+    /** Go to the previous page */
+    prevPage: () => void;
+}
+declare function useTradeHistory({ ticker, pageSize, }?: UseTradeHistoryParams): UseTradeHistoryResult;
+
+interface TradeHistoryUIProps {
+    /** List of trades for current page */
+    trades: SingleTradeResponse[];
+    /** Whether data is loading */
+    isLoading: boolean;
+    /** Whether background refetch is in progress */
+    isFetching: boolean;
+    /** Current page (1-based) */
+    page: number;
+    /** Whether more pages exist */
+    hasNextPage: boolean;
+    /** Whether a previous page exists */
+    hasPrevPage: boolean;
+    /** Go to next page */
+    onNextPage: () => void;
+    /** Go to previous page */
+    onPrevPage: () => void;
+}
+declare function TradeHistoryUI({ trades, isLoading, isFetching, page, hasNextPage, hasPrevPage, onNextPage, onPrevPage, }: TradeHistoryUIProps): react_jsx_runtime.JSX.Element;
+
+interface TradeHistoryWidgetProps {
+    /** Optional filter by market ticker */
+    ticker?: string;
+    /** Page size (default: DEFAULT_PAGE_SIZE) */
+    pageSize?: number;
+}
+declare function TradeHistoryWidget({ ticker, pageSize, }?: TradeHistoryWidgetProps): react_jsx_runtime.JSX.Element;
+
+interface UsePositionsParams {
+    /** Polling interval in ms (0 to disable) */
+    refetchInterval?: number;
+}
+/**
+ * @deprecated Position type - not provided by new API
+ */
+interface Position {
+    id: string;
+    marketId: string;
+    marketTitle: string;
+    outcome: "yes" | "no";
+    quantity: number;
+    avgPrice: number;
+    avgCostBasis: number;
+    currentPrice: number;
+    unrealizedPnl: number;
+    realizedPnl: number;
+}
+interface PositionsSummary {
+    /** Total market value in cents */
+    totalValue: number;
+    /** Total unrealised PnL in cents */
+    totalUnrealizedPnl: number;
+    /** Total realised PnL in cents */
+    totalRealizedPnl: number;
+    /** Number of positions */
+    count: number;
+}
+interface UsePositionsResult {
+    /** Positions list */
+    positions: Position[];
+    /** Whether data is loading */
+    isLoading: boolean;
+    /** Whether a background refetch is in progress */
+    isFetching: boolean;
+    /** Aggregated summary across all positions */
+    summary: PositionsSummary;
+}
+/**
+ * @deprecated This hook is deprecated. The new dflow API does not provide
+ * positions data. Use on-chain token balance queries instead.
+ */
+declare function usePositions(_params?: UsePositionsParams): UsePositionsResult;
+
+interface PositionsUIProps {
+    /** List of positions */
+    positions: Position[];
+    /** Whether data is loading */
+    isLoading: boolean;
+    /** Aggregated summary */
+    summary: PositionsSummary;
+    /** Callback when a position's sell button is clicked */
+    onSell?: (position: Position) => void;
+}
+declare function PositionsUI({ positions, isLoading, summary, onSell, }: PositionsUIProps): react_jsx_runtime.JSX.Element;
+
+interface PositionsWidgetProps {
+    /** Polling interval in ms (default 15000, 0 to disable) */
+    refetchInterval?: number;
+    /** Callback when a position's sell action is triggered */
+    onSell?: (position: Position) => void;
+}
+/**
+ * @deprecated This widget is deprecated. Use on-chain token balance queries instead.
+ */
+declare function PositionsWidget({ refetchInterval, onSell, }?: PositionsWidgetProps): react_jsx_runtime.JSX.Element;
 
 interface PredictContextValue {
+    /** The predict API client instance */
     client: IPredictClient;
+    /** The WebSocket client instance for real-time data */
+    wsClient: IPredictWsClient | null;
 }
 declare const PredictContext: react.Context<PredictContextValue>;
 
 type PredictProviderProps = PropsWithChildren<{
+    /** The predict API client instance */
     client: IPredictClient;
+    /** WebSocket client instance (optional, enables WebSocket features) */
+    wsClient?: IPredictWsClient | null;
 }>;
-declare function PredictProvider({ client, children }: PredictProviderProps): react_jsx_runtime.JSX.Element;
+declare function PredictProvider({ client, wsClient, children, }: PredictProviderProps): react_jsx_runtime.JSX.Element;
 
 declare function usePredictContext(): PredictContextValue;
 
 declare function usePredictClient(): IPredictClient;
 
-declare function marketsQueryKey(options?: MarketQueryOptions): unknown[];
-declare function fetchMarkets(client: IPredictClient, options?: MarketQueryOptions): Promise<Market[]>;
-declare function useMarketsQuery(options?: MarketQueryOptions, queryOptions?: Omit<UseQueryOptions<Market[], Error, Market[], unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<Market[], Error>;
+declare function eventsQueryKey(params?: EventQueryParams): unknown[];
+declare function fetchEvents(client: IPredictClient, params?: EventQueryParams): Promise<StandardEventsResponse>;
+declare function useEventsQuery(params?: EventQueryParams, queryOptions?: Omit<UseQueryOptions<StandardEventsResponse, Error, StandardEventsResponse, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<StandardEventsResponse, Error>;
+
+declare function eventsInfiniteQueryKey(params?: Omit<EventQueryParams, "cursor">): unknown[];
+declare function useEventsInfiniteQuery(params?: Omit<EventQueryParams, "cursor">, options?: Omit<UseInfiniteQueryOptions<StandardEventsResponse, Error, InfiniteData<StandardEventsResponse>, unknown[], number | undefined>, "queryKey" | "queryFn" | "getNextPageParam" | "initialPageParam">): _tanstack_react_query.UseInfiniteQueryResult<InfiniteData<StandardEventsResponse, unknown>, Error>;
+
+interface UseEventByIdQueryParams {
+    /** Event ticker ID */
+    id: string;
+    /** Include nested markets in response */
+    withNestedMarkets?: boolean;
+}
+declare function eventByIdQueryKey(params: UseEventByIdQueryParams): unknown[];
+declare function fetchEventById(client: IPredictClient, params: UseEventByIdQueryParams): Promise<StandardEvent>;
+declare function useEventByIdQuery(params: UseEventByIdQueryParams, options?: Omit<UseQueryOptions<StandardEvent, Error, StandardEvent, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<StandardEvent, Error>;
+
+declare function marketsQueryKey(params?: MarketQueryParams): unknown[];
+declare function fetchMarkets(client: IPredictClient, params?: MarketQueryParams): Promise<StandardMarketsResponse>;
+declare function useMarketsQuery(params?: MarketQueryParams, queryOptions?: Omit<UseQueryOptions<StandardMarketsResponse, Error, StandardMarketsResponse, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<StandardMarketsResponse, Error>;
 
 interface UseMarketByIdQueryParams {
+    /** Market ticker ID */
     id: string;
-    includeTag?: boolean;
 }
 declare function marketByIdQueryKey(params: UseMarketByIdQueryParams): unknown[];
-declare function fetchMarketById(client: IPredictClient, params: UseMarketByIdQueryParams): Promise<Market>;
-declare function useMarketByIdQuery(params: UseMarketByIdQueryParams, options?: Omit<UseQueryOptions<Market, Error, Market, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<Market, Error>;
+declare function fetchMarketById(client: IPredictClient, params: UseMarketByIdQueryParams): Promise<StandardMarket>;
+declare function useMarketByIdQuery(params: UseMarketByIdQueryParams, options?: Omit<UseQueryOptions<StandardMarket, Error, StandardMarket, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<StandardMarket, Error>;
+
+declare function marketByMintQueryKey(mintAddress: string): unknown[];
+declare function fetchMarketByMint(client: IPredictClient, mintAddress: string): Promise<StandardMarket>;
+declare function useMarketByMintQuery(mintAddress: string, options?: Omit<UseQueryOptions<StandardMarket, Error, StandardMarket, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<StandardMarket, Error>;
+
+declare function marketsBatchQueryKey(request: MarketsBatchRequest): unknown[];
+declare function fetchMarketsBatch(client: IPredictClient, request: MarketsBatchRequest): Promise<StandardMarketsResponse>;
+declare function useMarketsBatchQuery(request: MarketsBatchRequest, options?: Omit<UseQueryOptions<StandardMarketsResponse, Error, StandardMarketsResponse, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<StandardMarketsResponse, Error>;
+
+declare function orderBookQueryKey(marketTicker: string): unknown[];
+declare function fetchOrderBook(client: IPredictClient, marketTicker: string): Promise<OrderbookResponse>;
+declare function useOrderBookQuery(marketTicker: string, options?: Omit<UseQueryOptions<OrderbookResponse, Error, OrderbookResponse, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<OrderbookResponse, Error>;
+declare function orderBookByMintQueryKey(mintAddress: string): unknown[];
+declare function fetchOrderBookByMint(client: IPredictClient, mintAddress: string): Promise<OrderbookResponse>;
+declare function useOrderBookByMintQuery(mintAddress: string, options?: Omit<UseQueryOptions<OrderbookResponse, Error, OrderbookResponse, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<OrderbookResponse, Error>;
+
+declare function tradesQueryKey(params?: TradesQueryParams): unknown[];
+declare function fetchTrades(client: IPredictClient, params?: TradesQueryParams): Promise<MultiTradeResponse>;
+declare function useTradesQuery(params?: TradesQueryParams, queryOptions?: Omit<UseQueryOptions<MultiTradeResponse, Error, MultiTradeResponse, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<MultiTradeResponse, Error>;
+declare function tradesByMintQueryKey(params: TradesByMintQueryParams): unknown[];
+declare function fetchTradesByMint(client: IPredictClient, params: TradesByMintQueryParams): Promise<MultiTradeResponse>;
+declare function useTradesByMintQuery(params: TradesByMintQueryParams, queryOptions?: Omit<UseQueryOptions<MultiTradeResponse, Error, MultiTradeResponse, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<MultiTradeResponse, Error>;
 
-interface UseMarketBySlugQueryParams {
-    slug: string;
-    includeTag?: boolean;
+interface UseEventCandlesticksParams extends CandlesticksQueryParams {
+    /** Event ticker */
+    ticker: string;
 }
-declare function marketBySlugQueryKey(params: UseMarketBySlugQueryParams): unknown[];
-declare function fetchMarketBySlug(client: IPredictClient, params: UseMarketBySlugQueryParams): Promise<Market>;
-declare function useMarketBySlugQuery(params: UseMarketBySlugQueryParams, options?: Omit<UseQueryOptions<Market, Error, Market, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<Market, Error>;
+declare function eventCandlesticksQueryKey(params: UseEventCandlesticksParams): unknown[];
+declare function fetchEventCandlesticks(client: IPredictClient, params: UseEventCandlesticksParams): Promise<CandlesticksResponse>;
+declare function useEventCandlesticksQuery(params: UseEventCandlesticksParams, options?: Omit<UseQueryOptions<CandlesticksResponse, Error, CandlesticksResponse, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<CandlesticksResponse, Error>;
+interface UseMarketCandlesticksParams extends CandlesticksQueryParams {
+    /** Market ticker */
+    ticker: string;
+}
+declare function marketCandlesticksQueryKey(params: UseMarketCandlesticksParams): unknown[];
+declare function fetchMarketCandlesticks(client: IPredictClient, params: UseMarketCandlesticksParams): Promise<CandlesticksResponse>;
+declare function useMarketCandlesticksQuery(params: UseMarketCandlesticksParams, options?: Omit<UseQueryOptions<CandlesticksResponse, Error, CandlesticksResponse, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<CandlesticksResponse, Error>;
+interface UseMarketCandlesticksByMintParams extends CandlesticksQueryParams {
+    /** Mint address */
+    mintAddress: string;
+}
+declare function marketCandlesticksByMintQueryKey(params: UseMarketCandlesticksByMintParams): unknown[];
+declare function fetchMarketCandlesticksByMint(client: IPredictClient, params: UseMarketCandlesticksByMintParams): Promise<CandlesticksResponse>;
+declare function useMarketCandlesticksByMintQuery(params: UseMarketCandlesticksByMintParams, options?: Omit<UseQueryOptions<CandlesticksResponse, Error, CandlesticksResponse, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<CandlesticksResponse, Error>;
+/** @deprecated Use useEventCandlesticksQuery or useMarketCandlesticksQuery instead */
+declare const usePriceHistoryQuery: typeof useMarketCandlesticksQuery;
 
-declare function marketTagsByIdQueryKey(id: string): unknown[];
-declare function fetchMarketTagsById(client: IPredictClient, id: string): Promise<MarketTag[]>;
-declare function useMarketTagsByIdQuery(id: string, options?: Omit<UseQueryOptions<MarketTag[], Error, MarketTag[], unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<MarketTag[], Error>;
+declare function forecastPercentileHistoryQueryKey(params: ForecastPercentileHistoryQueryParams): unknown[];
+declare function fetchForecastPercentileHistory(client: IPredictClient, params: ForecastPercentileHistoryQueryParams): Promise<ForecastPercentileHistoryResponse>;
+declare function useForecastPercentileHistoryQuery(params: ForecastPercentileHistoryQueryParams, options?: Omit<UseQueryOptions<ForecastPercentileHistoryResponse, Error, ForecastPercentileHistoryResponse, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<ForecastPercentileHistoryResponse, Error>;
+declare function forecastPercentileHistoryByMintQueryKey(params: ForecastPercentileHistoryByMintQueryParams): unknown[];
+declare function fetchForecastPercentileHistoryByMint(client: IPredictClient, params: ForecastPercentileHistoryByMintQueryParams): Promise<ForecastPercentileHistoryResponse>;
+declare function useForecastPercentileHistoryByMintQuery(params: ForecastPercentileHistoryByMintQueryParams, options?: Omit<UseQueryOptions<ForecastPercentileHistoryResponse, Error, ForecastPercentileHistoryResponse, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<ForecastPercentileHistoryResponse, Error>;
 
-declare function searchQueryKey(options: SearchQueryOptions): unknown[];
-declare function fetchSearch(client: IPredictClient, options: SearchQueryOptions): Promise<SearchResult>;
-declare function useSearchQuery(options: SearchQueryOptions, queryOptions?: Omit<UseQueryOptions<SearchResult, Error, SearchResult, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<SearchResult, Error>;
+declare function liveDataQueryKey(params: LiveDataQueryParams): unknown[];
+declare function fetchLiveData(client: IPredictClient, params: LiveDataQueryParams): Promise<LiveDataResponse>;
+declare function useLiveDataQuery(params: LiveDataQueryParams, options?: Omit<UseQueryOptions<LiveDataResponse, Error, LiveDataResponse, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<LiveDataResponse, Error>;
+declare function liveDataByEventQueryKey(params: LiveDataByEventQueryParams): unknown[];
+declare function fetchLiveDataByEvent(client: IPredictClient, params: LiveDataByEventQueryParams): Promise<LiveDataResponse>;
+declare function useLiveDataByEventQuery(params: LiveDataByEventQueryParams, options?: Omit<UseQueryOptions<LiveDataResponse, Error, LiveDataResponse, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<LiveDataResponse, Error>;
+declare function liveDataByMintQueryKey(params: LiveDataByMintQueryParams): unknown[];
+declare function fetchLiveDataByMint(client: IPredictClient, params: LiveDataByMintQueryParams): Promise<LiveDataResponse>;
+declare function useLiveDataByMintQuery(params: LiveDataByMintQueryParams, options?: Omit<UseQueryOptions<LiveDataResponse, Error, LiveDataResponse, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<LiveDataResponse, Error>;
 
-declare function marketPriceQueryKey(query: MarketPriceQuery): unknown[];
-declare function fetchMarketPrice(client: IPredictClient, query: MarketPriceQuery): Promise<MarketPrice>;
-declare function useMarketPriceQuery(query: MarketPriceQuery, options?: Omit<UseQueryOptions<MarketPrice, Error, MarketPrice, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<MarketPrice, Error>;
+declare function seriesQueryKey(params?: SeriesQueryParams): unknown[];
+declare function fetchSeries(client: IPredictClient, params?: SeriesQueryParams): Promise<SeriesListResponse>;
+declare function useSeriesQuery(params?: SeriesQueryParams, queryOptions?: Omit<UseQueryOptions<SeriesListResponse, Error, SeriesListResponse, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<SeriesListResponse, Error>;
+declare function seriesByTickerQueryKey(seriesTicker: string): unknown[];
+declare function fetchSeriesByTicker(client: IPredictClient, seriesTicker: string): Promise<SeriesResponse>;
+declare function useSeriesByTickerQuery(seriesTicker: string, options?: Omit<UseQueryOptions<SeriesResponse, Error, SeriesResponse, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<SeriesResponse, Error>;
 
-declare function multipleMarketPricesQueryKey(): unknown[];
-declare function fetchMultipleMarketPrices(client: IPredictClient): Promise<MultipleMarketPrices>;
-declare function useMultipleMarketPricesQuery(options?: Omit<UseQueryOptions<MultipleMarketPrices, Error, MultipleMarketPrices, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<MultipleMarketPrices, Error>;
+declare function tagsByCategoriesQueryKey(): unknown[];
+declare function fetchTagsByCategories(client: IPredictClient): Promise<TagsByCategoriesResponse>;
+declare function useTagsByCategoriesQuery(options?: Omit<UseQueryOptions<TagsByCategoriesResponse, Error, TagsByCategoriesResponse, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<TagsByCategoriesResponse, Error>;
+declare function filtersBySportsQueryKey(): unknown[];
+declare function fetchFiltersBySports(client: IPredictClient): Promise<FiltersBySportsResponse>;
+declare function useFiltersBySportsQuery(options?: Omit<UseQueryOptions<FiltersBySportsResponse, Error, FiltersBySportsResponse, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<FiltersBySportsResponse, Error>;
+/** @deprecated Use useTagsByCategoriesQuery instead */
+declare const useCategoriesQuery: typeof useTagsByCategoriesQuery;
 
-declare function multipleMarketPricesByRequestQueryKey(requests: MarketPriceRequestItem[]): unknown[];
-declare function fetchMultipleMarketPricesByRequest(client: IPredictClient, requests: MarketPriceRequestItem[]): Promise<MultipleMarketPrices>;
-declare function useMultipleMarketPricesByRequestQuery(requests: MarketPriceRequestItem[], options?: Omit<UseQueryOptions<MultipleMarketPrices, Error, MultipleMarketPrices, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<MultipleMarketPrices, Error>;
+declare function searchQueryKey(params: SearchQueryParams): unknown[];
+declare function fetchSearch(client: IPredictClient, params: SearchQueryParams): Promise<SearchResponse>;
+declare function useSearchQuery(params: SearchQueryParams, queryOptions?: Omit<UseQueryOptions<SearchResponse, Error, SearchResponse, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<SearchResponse, Error>;
 
-declare function priceHistoryQueryKey(query: PriceHistoryQuery): unknown[];
-declare function fetchPriceHistory(client: IPredictClient, query: PriceHistoryQuery): Promise<PriceHistory>;
-declare function usePriceHistoryQuery(query: PriceHistoryQuery, options?: Omit<UseQueryOptions<PriceHistory, Error, PriceHistory, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<PriceHistory, Error>;
+declare function outcomeMintsQueryKey(params?: OutcomeMintsQueryParams): unknown[];
+declare function fetchOutcomeMints(client: IPredictClient, params?: OutcomeMintsQueryParams): Promise<OutcomeMintsResponse>;
+declare function useOutcomeMintsQuery(params?: OutcomeMintsQueryParams, options?: Omit<UseQueryOptions<OutcomeMintsResponse, Error, OutcomeMintsResponse, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<OutcomeMintsResponse, Error>;
+declare function filterOutcomeMints(client: IPredictClient, request: FilterOutcomeMintsRequest): Promise<FilterOutcomeMintsResponse>;
+declare function useFilterOutcomeMintsMutation(options?: Omit<UseMutationOptions<FilterOutcomeMintsResponse, Error, FilterOutcomeMintsRequest>, "mutationFn">): _tanstack_react_query.UseMutationResult<FilterOutcomeMintsResponse, Error, FilterOutcomeMintsRequest, unknown>;
 
-declare function eventsQueryKey(options?: EventQueryOptions): unknown[];
-declare function fetchEvents(client: IPredictClient, options?: EventQueryOptions): Promise<Event[]>;
-declare function useEventsQuery(options?: EventQueryOptions, queryOptions?: Omit<UseQueryOptions<Event[], Error, Event[], unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<Event[], Error>;
+declare function quoteQueryKey(params: QuoteQueryParams): unknown[];
+declare function fetchQuote(client: IPredictClient, params: QuoteQueryParams): Promise<QuoteResponse>;
+declare function useQuoteQuery(params: QuoteQueryParams, options?: Omit<UseQueryOptions<QuoteResponse, Error, QuoteResponse, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<QuoteResponse, Error>;
 
-interface UseEventByIdQueryParams {
-    id: string;
-    includeChat?: boolean;
-    includeTemplate?: boolean;
+declare function createSwap(client: IPredictClient, request: SwapRequestBody): Promise<SwapResponse>;
+declare function useCreateSwapMutation(options?: Omit<UseMutationOptions<SwapResponse, Error, SwapRequestBody>, "mutationFn">): _tanstack_react_query.UseMutationResult<SwapResponse, Error, SwapRequestBody, unknown>;
+declare function createSwapInstructions(client: IPredictClient, request: SwapRequestBody): Promise<SwapInstructionsResponse>;
+declare function useCreateSwapInstructionsMutation(options?: Omit<UseMutationOptions<SwapInstructionsResponse, Error, SwapRequestBody>, "mutationFn">): _tanstack_react_query.UseMutationResult<SwapInstructionsResponse, Error, SwapRequestBody, unknown>;
+
+declare function orderQueryKey(params: OrderQueryParams): unknown[];
+declare function fetchOrder(client: IPredictClient, params: OrderQueryParams): Promise<OrderResponse>;
+declare function useOrderQuery(params: OrderQueryParams, options?: Omit<UseQueryOptions<OrderResponse, Error, OrderResponse, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<OrderResponse, Error>;
+declare function orderStatusQueryKey(params: OrderStatusQueryParams): unknown[];
+declare function fetchOrderStatus(client: IPredictClient, params: OrderStatusQueryParams): Promise<OrderStatusResponse>;
+declare function useOrderStatusQuery(params: OrderStatusQueryParams, options?: Omit<UseQueryOptions<OrderStatusResponse, Error, OrderStatusResponse, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<OrderStatusResponse, Error>;
+
+declare function intentQuoteQueryKey(params: IntentQuoteQueryParams): unknown[];
+declare function fetchIntentQuote(client: IPredictClient, params: IntentQuoteQueryParams): Promise<IntentQuoteResponse>;
+declare function useIntentQuoteQuery(params: IntentQuoteQueryParams, options?: Omit<UseQueryOptions<IntentQuoteResponse, Error, IntentQuoteResponse, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<IntentQuoteResponse, Error>;
+declare function submitIntentSwap(client: IPredictClient, request: IntentSwapRequestBody): Promise<IntentSwapResponse>;
+declare function useSubmitIntentSwapMutation(options?: Omit<UseMutationOptions<IntentSwapResponse, Error, IntentSwapRequestBody>, "mutationFn">): _tanstack_react_query.UseMutationResult<IntentSwapResponse, Error, IntentSwapRequestBody, unknown>;
+
+declare function initPredictionMarket(client: IPredictClient, params: PredictionMarketInitQueryParams): Promise<PredictionMarketInitResponse>;
+declare function useInitPredictionMarketMutation(options?: Omit<UseMutationOptions<PredictionMarketInitResponse, Error, PredictionMarketInitQueryParams>, "mutationFn">): _tanstack_react_query.UseMutationResult<PredictionMarketInitResponse, Error, PredictionMarketInitQueryParams, unknown>;
+
+declare function tokensQueryKey(): unknown[];
+declare function fetchTokens(client: IPredictClient): Promise<TokenListResponse>;
+declare function useTokensQuery(options?: Omit<UseQueryOptions<TokenListResponse, Error, TokenListResponse, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<TokenListResponse, Error>;
+declare function tokensWithDecimalsQueryKey(): unknown[];
+declare function fetchTokensWithDecimals(client: IPredictClient): Promise<TokenListWithDecimalsResponse>;
+declare function useTokensWithDecimalsQuery(options?: Omit<UseQueryOptions<TokenListWithDecimalsResponse, Error, TokenListWithDecimalsResponse, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<TokenListWithDecimalsResponse, Error>;
+
+declare function venuesQueryKey(): unknown[];
+declare function fetchVenues(client: IPredictClient): Promise<VenueListResponse>;
+declare function useVenuesQuery(options?: Omit<UseQueryOptions<VenueListResponse, Error, VenueListResponse, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<VenueListResponse, Error>;
+
+interface UseWsConnectionParams {
+    /** WebSocket endpoint URL */
+    wsEndpoint: string;
+    /** Auto-connect on mount (default: true) */
+    autoConnect?: boolean;
+    /** Auto-reconnect on disconnect (default: true) */
+    autoReconnect?: boolean;
+    /** Enable connection (default: true) */
+    enabled?: boolean;
 }
-declare function eventByIdQueryKey(params: UseEventByIdQueryParams): unknown[];
-declare function fetchEventById(client: IPredictClient, params: UseEventByIdQueryParams): Promise<Event>;
-declare function useEventByIdQuery(params: UseEventByIdQueryParams, options?: Omit<UseQueryOptions<Event, Error, Event, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<Event, Error>;
+interface UseWsConnectionResult {
+    /** WebSocket client instance */
+    client: IPredictWsClient | null;
+    /** Current connection status */
+    status: WsConnectionStatus;
+    /** Whether currently connected */
+    isConnected: boolean;
+    /** Connect to WebSocket */
+    connect: () => void;
+    /** Disconnect from WebSocket */
+    disconnect: () => void;
+    /** Last error */
+    error: Error | null;
+}
+/**
+ * Hook for managing WebSocket connection lifecycle
+ */
+declare function useWsConnection({ wsEndpoint, autoConnect, autoReconnect, enabled, }: UseWsConnectionParams): UseWsConnectionResult;
 
-declare function eventTagsByIdQueryKey(id: string): unknown[];
-declare function fetchEventTagsById(client: IPredictClient, id: string): Promise<MarketTag[]>;
-declare function useEventTagsByIdQuery(id: string, options?: Omit<UseQueryOptions<MarketTag[], Error, MarketTag[], unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<MarketTag[], Error>;
+interface UseWsClientResult {
+    /** WebSocket client instance (null if not configured) */
+    wsClient: IPredictWsClient | null;
+    /** Current connection status */
+    wsStatus: WsConnectionStatus;
+    /** Whether currently connected */
+    isWsConnected: boolean;
+}
+/**
+ * Hook to access the WebSocket client from PredictContext.
+ * Connection status is derived directly from the wsClient instance.
+ */
+declare function useWsClient(): UseWsClientResult;
+
+interface UsePricesSubscriptionParams {
+    /** WebSocket client instance */
+    client: IPredictWsClient | null;
+    /** Subscribe to all markets */
+    all?: boolean;
+    /** Subscribe to specific market tickers */
+    tickers?: string[];
+    /** Enable subscription (default: true) */
+    enabled?: boolean;
+    /** Callback when price update received */
+    onUpdate?: (update: WsPriceUpdate) => void;
+}
+interface PriceData {
+    yesBid: string | null;
+    yesAsk: string | null;
+    noBid: string | null;
+    noAsk: string | null;
+    updatedAt: number;
+}
+interface UsePricesSubscriptionResult {
+    /** Map of market ticker to latest price data */
+    prices: Map<string, PriceData>;
+    /** Whether subscription is active */
+    isSubscribed: boolean;
+}
+/**
+ * Hook for subscribing to real-time price updates
+ */
+declare function usePricesSubscription({ client, all, tickers, enabled, onUpdate, }: UsePricesSubscriptionParams): UsePricesSubscriptionResult;
+
+interface UseTradesSubscriptionParams {
+    /** WebSocket client instance */
+    client: IPredictWsClient | null;
+    /** Subscribe to all markets */
+    all?: boolean;
+    /** Subscribe to specific market tickers */
+    tickers?: string[];
+    /** Enable subscription (default: true) */
+    enabled?: boolean;
+    /** Maximum number of trades to keep in history (default: 100) */
+    maxHistory?: number;
+    /** Callback when trade update received */
+    onUpdate?: (update: WsTradeUpdate) => void;
+}
+interface TradeData {
+    tradeId: string;
+    marketTicker: string;
+    price: number;
+    count: number;
+    yesPrice: number;
+    noPrice: number;
+    takerSide: "yes" | "no";
+    createdTime: number;
+}
+interface UseTradesSubscriptionResult {
+    /** Recent trades (newest first) */
+    trades: TradeData[];
+    /** Whether subscription is active */
+    isSubscribed: boolean;
+    /** Clear trade history */
+    clearHistory: () => void;
+}
+/**
+ * Hook for subscribing to real-time trade updates
+ */
+declare function useTradesSubscription({ client, all, tickers, enabled, maxHistory, onUpdate, }: UseTradesSubscriptionParams): UseTradesSubscriptionResult;
 
-declare function eventBySlugQueryKey(slug: string): unknown[];
-declare function fetchEventBySlug(client: IPredictClient, slug: string): Promise<Event>;
-declare function useEventBySlugQuery(slug: string, options?: Omit<UseQueryOptions<Event, Error, Event, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<Event, Error>;
+interface UseOrderbookSubscriptionParams {
+    /** WebSocket client instance */
+    client: IPredictWsClient | null;
+    /** Subscribe to all markets */
+    all?: boolean;
+    /** Subscribe to specific market tickers */
+    tickers?: string[];
+    /** Enable subscription (default: true) */
+    enabled?: boolean;
+    /** Callback when orderbook update received */
+    onUpdate?: (update: WsOrderbookUpdate) => void;
+}
+interface OrderbookData {
+    yesBids: OrderbookLevel[];
+    yesAsks: OrderbookLevel[];
+    noBids: OrderbookLevel[];
+    noAsks: OrderbookLevel[];
+    updatedAt: number;
+}
+interface UseOrderbookSubscriptionResult {
+    /** Map of market ticker to latest orderbook data */
+    orderbooks: Map<string, OrderbookData>;
+    /** Whether subscription is active */
+    isSubscribed: boolean;
+    /** Get orderbook for a specific ticker */
+    getOrderbook: (ticker: string) => OrderbookData | undefined;
+}
+/**
+ * Hook for subscribing to real-time orderbook updates
+ */
+declare function useOrderbookSubscription({ client, all, tickers, enabled, onUpdate, }: UseOrderbookSubscriptionParams): UseOrderbookSubscriptionResult;
 
-export { Event, EventDetailSkeleton, type EventDetailSkeletonProps, EventDetailUI, type EventDetailUIProps, EventDetailWidget, type EventDetailWidgetProps, EventItemSkeleton, type EventItemSkeletonProps, EventItemUI, type EventItemUIProps, EventQueryOptions, EventsSkeleton, type EventsSkeletonProps, EventsUI, type EventsUIProps, EventsWidget, type EventsWidgetProps, IPredictClient, Market, MarketPrice, MarketPriceQuery, MarketPriceRequestItem, MarketQueryOptions, MarketTag, MultipleMarketPrices, PredictContext, type PredictContextValue, PredictProvider, type PredictProviderProps, PriceHistory, PriceHistoryInterval, PriceHistoryQuery, SearchQueryOptions, SearchResult, type UseEventByIdQueryParams, type UseEventDetailParams, type UseEventsParams, type UseEventsResult, type UseMarketByIdQueryParams, type UseMarketBySlugQueryParams, eventByIdQueryKey, eventBySlugQueryKey, eventTagsByIdQueryKey, eventsQueryKey, fetchEventById, fetchEventBySlug, fetchEventTagsById, fetchEvents, fetchMarketById, fetchMarketBySlug, fetchMarketPrice, fetchMarketTagsById, fetchMarkets, fetchMultipleMarketPrices, fetchMultipleMarketPricesByRequest, fetchPriceHistory, fetchSearch, marketByIdQueryKey, marketBySlugQueryKey, marketPriceQueryKey, marketTagsByIdQueryKey, marketsQueryKey, multipleMarketPricesByRequestQueryKey, multipleMarketPricesQueryKey, priceHistoryQueryKey, searchQueryKey, useEventByIdQuery, useEventBySlugQuery, useEventDetail, useEventTagsByIdQuery, useEvents, useEventsQuery, useMarketByIdQuery, useMarketBySlugQuery, useMarketPriceQuery, useMarketTagsByIdQuery, useMarketsQuery, useMultipleMarketPricesByRequestQuery, useMultipleMarketPricesQuery, usePredictClient, usePredictContext, usePriceHistoryQuery, useSearchQuery, _default as version };
+export { CHART_RANGE_DURATION, CHART_RANGE_PERIOD, CHART_RANGE_SAMPLE_INTERVAL, CandlestickPeriod, type CandlestickPeriodType, CandlesticksQueryParams, CandlesticksResponse, ChartRange, type ChartRangeType, DEFAULT_CHART_RANGE, DEFAULT_PAGE_SIZE, DEFAULT_PRICE_HISTORY_INTERVAL, EventDetailPage, type EventDetailPageProps, EventDetailSkeleton, type EventDetailSkeletonProps, EventDetailUI, type EventDetailUIProps, EventDetailWidget, type EventDetailWidgetProps, EventItemSkeleton, type EventItemSkeletonProps, EventItemUI, type EventItemUIProps, EventMarketDetailWidget, type EventMarketDetailWidgetProps, EventQueryParams, EventsSkeleton, type EventsSkeletonProps, EventsUI, type EventsUIProps, EventsWidget, type EventsWidgetProps, FilterOutcomeMintsRequest, FilterOutcomeMintsResponse, FiltersBySportsResponse, ForecastPercentileHistoryByMintQueryParams, ForecastPercentileHistoryQueryParams, ForecastPercentileHistoryResponse, IPredictClient, IPredictWsClient, IntentQuoteQueryParams, IntentQuoteResponse, IntentSwapRequestBody, IntentSwapResponse, LiveDataByEventQueryParams, LiveDataByMintQueryParams, LiveDataQueryParams, LiveDataResponse, MAX_PRICE_HISTORY_MARKETS, MarketQueryParams, MarketsBatchRequest, MultiTradeResponse, ORDER_MAX_PRICE, ORDER_MIN_PRICE, ORDER_MIN_QUANTITY, ORDER_PRICE_STEP, OpenOrdersUI, type OpenOrdersUIProps, OpenOrdersWidget, type OpenOrdersWidgetProps, type Order, type OrderBookRow, OrderBookUI, type OrderBookUIProps, OrderBookWidget, type OrderBookWidgetProps, OrderQueryParams, OrderResponse, OrderStatusQueryParams, OrderStatusResponse, type OrderbookData, OrderbookLevel, OrderbookResponse, OutcomeMintsQueryParams, OutcomeMintsResponse, PRICE_HISTORY_SAMPLE_INTERVAL, type Position, type PositionsSummary, PositionsUI, type PositionsUIProps, PositionsWidget, type PositionsWidgetProps, PredictContext, type PredictContextValue, PredictProvider, type PredictProviderProps, PredictionMarketInitQueryParams, PredictionMarketInitResponse, type PriceData, PriceHistoryInterval, type PriceHistoryIntervalType, QuoteQueryParams, QuoteResponse, SearchQueryParams, SearchResponse, SeriesListResponse, SeriesQueryParams, SeriesResponse, SingleTradeResponse, StandardEvent, StandardEventsResponse, StandardMarket, StandardMarketsResponse, SwapInstructionsResponse, SwapRequestBody, SwapResponse, TagsByCategoriesResponse, TokenListResponse, TokenListWithDecimalsResponse, type TradeData, TradeFormSkeleton, TradeFormUI, type TradeFormUIProps, type TradeFormValidation, TradeFormWidget, type TradeFormWidgetProps, TradeHistoryUI, type TradeHistoryUIProps, TradeHistoryWidget, type TradeHistoryWidgetProps, type TradeOutcome, type TradeSide, TradesByMintQueryParams, TradesQueryParams, type UseEventByIdQueryParams, type UseEventCandlesticksParams, type UseEventDetailParams, type UseEventsParams, type UseEventsResult, type UseMarketByIdQueryParams, type UseMarketCandlesticksByMintParams, type UseMarketCandlesticksParams, type UseOpenOrdersParams, type UseOpenOrdersResult, type UseOrderBookParams, type UseOrderBookResult, type UseOrderbookSubscriptionParams, type UseOrderbookSubscriptionResult, type UsePositionsParams, type UsePositionsResult, type UsePricesSubscriptionParams, type UsePricesSubscriptionResult, type UseTradeFormParams, type UseTradeFormResult, type UseTradeHistoryParams, type UseTradeHistoryResult, type UseTradesSubscriptionParams, type UseTradesSubscriptionResult, type UseWsClientResult, type UseWsConnectionParams, type UseWsConnectionResult, VenueListResponse, WsConnectionStatus, WsOrderbookUpdate, WsPriceUpdate, WsTradeUpdate, createSwap, createSwapInstructions, eventByIdQueryKey, eventCandlesticksQueryKey, eventsInfiniteQueryKey, eventsQueryKey, fetchEventById, fetchEventCandlesticks, fetchEvents, fetchFiltersBySports, fetchForecastPercentileHistory, fetchForecastPercentileHistoryByMint, fetchIntentQuote, fetchLiveData, fetchLiveDataByEvent, fetchLiveDataByMint, fetchMarketById, fetchMarketByMint, fetchMarketCandlesticks, fetchMarketCandlesticksByMint, fetchMarkets, fetchMarketsBatch, fetchOrder, fetchOrderBook, fetchOrderBookByMint, fetchOrderStatus, fetchOutcomeMints, fetchQuote, fetchSearch, fetchSeries, fetchSeriesByTicker, fetchTagsByCategories, fetchTokens, fetchTokensWithDecimals, fetchTrades, fetchTradesByMint, fetchVenues, filterOutcomeMints, filtersBySportsQueryKey, forecastPercentileHistoryByMintQueryKey, forecastPercentileHistoryQueryKey, initPredictionMarket, intentQuoteQueryKey, liveDataByEventQueryKey, liveDataByMintQueryKey, liveDataQueryKey, marketByIdQueryKey, marketByMintQueryKey, marketCandlesticksByMintQueryKey, marketCandlesticksQueryKey, marketsBatchQueryKey, marketsQueryKey, orderBookByMintQueryKey, orderBookQueryKey, orderQueryKey, orderStatusQueryKey, outcomeMintsQueryKey, quoteQueryKey, searchQueryKey, seriesByTickerQueryKey, seriesQueryKey, submitIntentSwap, tagsByCategoriesQueryKey, tokensQueryKey, tokensWithDecimalsQueryKey, tradesByMintQueryKey, tradesQueryKey, useCategoriesQuery, useCreateSwapInstructionsMutation, useCreateSwapMutation, useEventByIdQuery, useEventCandlesticksQuery, useEventDetail, useEvents, useEventsInfiniteQuery, useEventsQuery, useFilterOutcomeMintsMutation, useFiltersBySportsQuery, useForecastPercentileHistoryByMintQuery, useForecastPercentileHistoryQuery, useInitPredictionMarketMutation, useIntentQuoteQuery, useLiveDataByEventQuery, useLiveDataByMintQuery, useLiveDataQuery, useMarketByIdQuery, useMarketByMintQuery, useMarketCandlesticksByMintQuery, useMarketCandlesticksQuery, useMarketsBatchQuery, useMarketsQuery, useOpenOrders, useOrderBook, useOrderBookByMintQuery, useOrderBookQuery, useOrderQuery, useOrderStatusQuery, useOrderbookSubscription, useOutcomeMintsQuery, usePositions, usePredictClient, usePredictContext, usePriceHistoryQuery, usePricesSubscription, useQuoteQuery, useSearchQuery, useSeriesByTickerQuery, useSeriesQuery, useSubmitIntentSwapMutation, useTagsByCategoriesQuery, useTokensQuery, useTokensWithDecimalsQuery, useTradeForm, useTradeHistory, useTradesByMintQuery, useTradesQuery, useTradesSubscription, useVenuesQuery, useWsClient, useWsConnection, venuesQueryKey, _default as version };