@liberfi.io/react-predict 0.1.1

package/dist/index.d.mts

@@ -0,0 +1,589 @@
+import { P as PredictClient, a as PredictWsClient, L as ListEventsParams, b as PredictPage, c as PredictEvent, d as ProviderSource, E as EventStatus, S as SimilarEventsParams, e as PredictMarket, O as Orderbook, f as ListMarketTradesParams, g as PredictTrade, h as PriceHistoryRange, i as PriceHistoryResponse, j as ListCandlesticksParams, C as Candlestick, k as PositionsResponse, B as BalanceResponse, l as ListOrdersParams, m as PredictOrder, n as CancelOrderResult, o as ListTradesParams, D as DFlowQuoteRequest, p as DFlowQuoteResponse, q as DFlowSubmitResponse, r as DFlowSubmitRequest, W as WsConnectionStatus, s as WsDataMessage, t as WsPriceEvent, u as WsOrderbookEvent, v as WsTradeEvent, w as CreateOrderInput } from './server-DlSG7h_v.mjs';
+export { at as BuildClobAuthMessageInput, aE as BuildOrderMessageInput, aG as BuildSignedOrderInput, ak as CLOB_AUTH_DOMAIN, al as CLOB_AUTH_TYPES, au as CTF_EXCHANGE_ADDRESS, az as CTF_ORDER_TYPES, Y as DFlowOrderContext, J as EventSortField, N as EventSummary, aq as HttpMethod, I as MarketOutcome, H as MarketResult, M as MarketStatus, Q as MarketSummary, av as NEG_RISK_CTF_EXCHANGE_ADDRESS, aA as ORDER_TYPE, aF as OrderMessage, X as OrderSide, V as OrderStatus, K as OrderbookLevel, ax as POLYGON_CHAIN_ID, as as PolymarketL2Headers, ar as PolymarketL2HeadersInput, Z as PolymarketOrderType, U as PredictPosition, F as PredictTag, z as PredictWsClientConfig, R as PricePoint, A as ProviderMeta, ae as ResolveEventsParamsInput, aB as SIDE, G as SettlementSource, aH as SignedOrder, af as TagSlugSelection, T as TradeType, aw as USDC_ADDRESS, aj as UseMarketParams, _ as WsChannel, $ as WsChannelEvent, a0 as WsClientMessage, a6 as WsErrorCode, a7 as WsErrorMessage, a2 as WsPingMessage, a4 as WsPongMessage, a3 as WsServerMessage, a1 as WsSubscribeMessage, a5 as WsSubscribedMessage, am as buildClobAuthMessage, ay as buildCtfExchangeDomain, aC as buildOrderMessage, ao as buildPolymarketL2Headers, aD as buildSignedOrder, x as createPredictClient, y as createPredictWsClient, ap as derivePolymarketApiKey, a8 as eventQueryKey, a9 as fetchEvent, ad as fetchEventsPage, ah as fetchMarket, an as hmacSha256Base64, ac as infiniteEventsQueryKey, ag as marketQueryKey, ab as resolveEventsParams, aa as resolveTagSlug, ai as useMarket } from './server-DlSG7h_v.mjs';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as react from 'react';
+import { PropsWithChildren } from 'react';
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { UseQueryOptions, UseInfiniteQueryOptions, InfiniteData, UseMutationOptions } from '@tanstack/react-query';
+
+type PredictProviderProps = PropsWithChildren<{
+    /**
+     * A `PredictClient` instance pointed at the prediction-server endpoint.
+     *
+     * @example
+     * ```tsx
+     * import { createPredictClient, PredictProvider } from "@liberfi.io/react-predict";
+     *
+     * const client = createPredictClient("https://api.example.com");
+     *
+     * <PredictProvider client={client}>
+     *   <App />
+     * </PredictProvider>
+     * ```
+     */
+    client: PredictClient;
+    /**
+     * Optional WebSocket client for real-time market data.
+     *
+     * When provided, subscription hooks (`usePricesSubscription`, etc.)
+     * and high-level realtime hooks (`useRealtimeOrderbook`, etc.) become
+     * functional. Without it they gracefully degrade to REST polling.
+     *
+     * @example
+     * ```tsx
+     * import { createPredictWsClient } from "@liberfi.io/react-predict";
+     *
+     * const wsClient = createPredictWsClient({
+     *   wsUrl: "wss://api.example.com/api/v1/ws",
+     * });
+     *
+     * <PredictProvider client={client} wsClient={wsClient}>
+     *   <App />
+     * </PredictProvider>
+     * ```
+     */
+    wsClient?: PredictWsClient | null;
+}>;
+/**
+ * Provides the prediction client via React context.
+ *
+ * Place this provider at the application root (or any subtree boundary)
+ * where prediction hooks are used.
+ */
+declare function PredictProvider({ client, wsClient, children, }: PredictProviderProps): react_jsx_runtime.JSX.Element;
+
+interface PredictContextValue {
+    /** The prediction-server HTTP client instance. */
+    client: PredictClient;
+    /** Optional WebSocket client for real-time data. `null` when not provided. */
+    wsClient: PredictWsClient | null;
+}
+/**
+ * Context that carries the prediction client (prediction-server backend).
+ *
+ * Consumers must be wrapped in `PredictProvider`.
+ */
+declare const PredictContext: react.Context<PredictContextValue | null>;
+
+type PolymarketProviderProps = PropsWithChildren<{
+    /**
+     * Polymarket CLOB API base URL.
+     * Defaults to `https://clob.polymarket.com`.
+     */
+    clobApiUrl?: string;
+}>;
+/**
+ * Provides in-memory Polymarket L2 credentials via React context.
+ *
+ * The provider is wallet-agnostic. Consumers call `authenticate(signer)` with
+ * a `PolymarketSigner` adapter, which handles the L1 EIP-712 signing step.
+ *
+ * Credentials are derived using `nonce=0` (permanent, deterministic) and are
+ * stored only in memory — they are cleared when the page unloads or when
+ * `clearCredentials()` is called.
+ *
+ * @example
+ * ```tsx
+ * <PolymarketProvider>
+ *   <App />
+ * </PolymarketProvider>
+ * ```
+ */
+declare function PolymarketProvider({ children }: PolymarketProviderProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Polymarket L2 API credentials derived from an L1 signature.
+ * These are stored in memory (never persisted) and cleared on page unload.
+ */
+interface PolymarketCredentials {
+    /** L2 API key (hex string). */
+    apiKey: string;
+    /** L2 HMAC secret (hex string). */
+    secret: string;
+    /** L2 passphrase (hex string). */
+    passphrase: string;
+    /** EVM wallet address that owns the credentials. */
+    address: string;
+}
+/**
+ * Minimal interface for signing EIP-712 typed data.
+ * Implemented by the consuming app (IoC — decouples from any wallet library).
+ *
+ * @example
+ * ```ts
+ * const signer: PolymarketSigner = {
+ *   address: walletAddress,
+ *   signatureType: 2, // EOA = 0, MAGIC_LINK = 1, POLY_PROXY = 2
+ *   signTypedData: async (domain, types, value) => {
+ *     const provider = await evmWalletAdapter.getEip1193Provider();
+ *     return provider.request({
+ *       method: "eth_signTypedData_v4",
+ *       params: [walletAddress, JSON.stringify({ domain, types, message: value })],
+ *     });
+ *   },
+ * };
+ * ```
+ */
+interface PolymarketSigner {
+    /** EVM address of the connected wallet. */
+    address: string;
+    /**
+     * Polymarket signature type:
+     * - `0` = EOA (MetaMask, Coinbase, etc.)
+     * - `1` = Magic Link
+     * - `2` = Polymarket proxy (Gnosis Safe)
+     */
+    signatureType: 0 | 1 | 2;
+    /**
+     * Sign EIP-712 typed data and return the hex signature.
+     * The signature is used for L1 authentication with the Polymarket CLOB API.
+     */
+    signTypedData: (domain: Record<string, unknown>, types: Record<string, unknown[]>, value: Record<string, unknown>) => Promise<string>;
+}
+interface PolymarketContextValue {
+    /** In-memory credentials; `null` before the user authenticates. */
+    credentials: PolymarketCredentials | null;
+    /** `true` while the L1 → L2 credential exchange is in progress. */
+    isAuthenticating: boolean;
+    /** Error from the last authentication attempt; `null` when clean. */
+    authError: Error | null;
+    /**
+     * Trigger L1 authentication using the provided signer.
+     * Derives L2 credentials with `nonce=0` and stores them in memory.
+     */
+    authenticate: (signer: PolymarketSigner) => Promise<void>;
+    /** Clear all in-memory credentials (e.g. on wallet disconnect). */
+    clearCredentials: () => void;
+}
+/**
+ * Context that carries Polymarket L2 credentials (in-memory only).
+ *
+ * Consumers must be wrapped in `PolymarketProvider`.
+ */
+declare const PolymarketContext: react.Context<PolymarketContextValue | null>;
+
+/**
+ * Returns the `PredictClient` instance from context.
+ *
+ * Must be called inside a component tree wrapped by `PredictProvider`.
+ *
+ * @throws When used outside of `PredictProvider`.
+ */
+declare function usePredictClient(): PredictClient;
+
+/** Stable TanStack Query key for the events list. */
+declare function eventsQueryKey(params?: ListEventsParams): unknown[];
+/**
+ * Fetch function usable outside React (e.g. in loaders or tests).
+ */
+declare function fetchEvents(client: ReturnType<typeof usePredictClient>, params?: ListEventsParams): Promise<PredictPage<PredictEvent>>;
+/**
+ * React Query hook for `GET /api/v1/events` via the prediction-server client.
+ *
+ * @param params - Optional filter / sort / pagination parameters.
+ * @param queryOptions - Additional TanStack Query options (e.g. `enabled`, `staleTime`).
+ *
+ * @example
+ * ```tsx
+ * const { data, isLoading } = useEvents({ status: "open", limit: 20 });
+ * ```
+ */
+declare function useEvents(params?: ListEventsParams, queryOptions?: Omit<UseQueryOptions<PredictPage<PredictEvent>, Error, PredictPage<PredictEvent>, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<PredictPage<PredictEvent>, Error>;
+
+interface UseEventParams {
+    /** Canonical event slug (e.g. "will-trump-win-2024" or "KXBTCD-25FEB-T68000"). */
+    slug: string;
+    /** Upstream provider. Required by prediction-server for single-event fetch. */
+    source?: ProviderSource;
+}
+/**
+ * React Query hook for `GET /api/v1/events/:slug` via the prediction-server client.
+ *
+ * @example
+ * ```tsx
+ * const { data, isLoading } = useEvent({ slug: "CONTROLH-2026", source: "dflow" });
+ * ```
+ */
+declare function useEvent(params: UseEventParams, queryOptions?: Omit<UseQueryOptions<PredictEvent, Error, PredictEvent, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<PredictEvent, Error>;
+
+type InfiniteQueryOptions = Omit<UseInfiniteQueryOptions<PredictPage<PredictEvent>, Error, InfiniteData<PredictPage<PredictEvent>>, unknown[], string | undefined>, "queryKey" | "queryFn" | "initialPageParam" | "getNextPageParam">;
+/**
+ * TanStack Query infinite-query hook for `GET /api/v1/events` with cursor-based
+ * pagination via the prediction-server client.
+ *
+ * @param params - Resolved query parameters (use {@link resolveEventsParams} to build
+ *                 from user inputs). Do NOT include `cursor` — it is managed automatically.
+ * @param queryOptions - Additional TanStack Query options.
+ *
+ * @example
+ * ```tsx
+ * const params = resolveEventsParams({ status: "open", limit: 20 });
+ * const { data, hasNextPage, fetchNextPage } = useInfiniteEvents(params);
+ * ```
+ */
+declare function useInfiniteEvents(params: ListEventsParams, queryOptions?: InfiniteQueryOptions): _tanstack_react_query.UseInfiniteQueryResult<InfiniteData<PredictPage<PredictEvent>, unknown>, Error>;
+
+interface UseSearchEventsParams {
+    /** Search keyword. */
+    keyword: string;
+    /** Page size (default: 20). */
+    limit?: number;
+    /** Event status filter (default: "open"). */
+    status?: EventStatus;
+    /** Filter by upstream provider. */
+    source?: ProviderSource;
+    /** Include nested markets (default: false for lighter search payloads). */
+    with_markets?: boolean;
+}
+/**
+ * Infinite query hook for searching prediction events via the `listEvents`
+ * endpoint with a `search` parameter.
+ *
+ * @example
+ * ```tsx
+ * const { data, isLoading, hasNextPage, fetchNextPage } =
+ *   useSearchEvents({ keyword: "trump" });
+ * ```
+ */
+declare function useSearchEvents(params: UseSearchEventsParams, queryOptions?: {
+    enabled?: boolean;
+}): _tanstack_react_query.UseInfiniteQueryResult<_tanstack_react_query.InfiniteData<PredictPage<PredictEvent>, unknown>, Error>;
+
+declare function similarEventsQueryKey(slug: string, source: ProviderSource, params?: SimilarEventsParams): unknown[];
+interface UseSimilarEventsParams {
+    slug: string;
+    source: ProviderSource;
+    limit?: number;
+    same_source?: boolean;
+}
+declare function useSimilarEvents(params: UseSimilarEventsParams, queryOptions?: Omit<UseQueryOptions<PredictEvent[], Error, PredictEvent[], unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<PredictEvent[], Error>;
+
+declare const ChartRange: {
+    readonly ONE_DAY: "1d";
+    readonly ONE_WEEK: "1w";
+    readonly ONE_MONTH: "1m";
+    readonly ALL: "all";
+};
+type ChartRangeType = (typeof ChartRange)[keyof typeof ChartRange];
+interface MarketHistoryPoint {
+    /** Unix timestamp in milliseconds. */
+    timestamp: number;
+    /** Implied probability [0, 1]. */
+    price: number;
+}
+interface MarketHistorySeries {
+    marketSlug: string;
+    label: string;
+    /** Chronologically ordered price history. */
+    data: MarketHistoryPoint[];
+}
+interface UseMarketHistoryResult {
+    series: MarketHistorySeries[];
+    isLoading: boolean;
+}
+/**
+ * Returns price history series for the provided markets using
+ * `GET /api/v1/markets/{slug}/price-history`.
+ */
+declare function useMarketHistory(markets: PredictMarket[], range?: ChartRangeType): UseMarketHistoryResult;
+
+declare function orderbookQueryKey(slug: string, source: ProviderSource): unknown[];
+interface UseOrderbookParams {
+    slug: string;
+    source: ProviderSource;
+}
+declare function useOrderbook(params: UseOrderbookParams, queryOptions?: Omit<UseQueryOptions<Orderbook, Error, Orderbook, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<Orderbook, Error>;
+
+declare function marketTradesQueryKey(slug: string, params: ListMarketTradesParams): unknown[];
+interface UseMarketTradesParams {
+    slug: string;
+    source: ProviderSource;
+    limit?: number;
+    cursor?: string;
+    side?: string;
+}
+declare function useMarketTrades(params: UseMarketTradesParams, queryOptions?: Omit<UseQueryOptions<PredictPage<PredictTrade>, Error, PredictPage<PredictTrade>, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<PredictPage<PredictTrade>, Error>;
+
+declare function priceHistoryQueryKey(slug: string, source: ProviderSource, range?: PriceHistoryRange): unknown[];
+interface UsePriceHistoryParams {
+    slug: string;
+    source: ProviderSource;
+    range?: PriceHistoryRange;
+}
+declare function usePriceHistory(params: UsePriceHistoryParams, queryOptions?: Omit<UseQueryOptions<PriceHistoryResponse, Error, PriceHistoryResponse, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<PriceHistoryResponse, Error>;
+
+declare function candlesticksQueryKey(slug: string, params?: ListCandlesticksParams): unknown[];
+interface UseCandlesticksParams {
+    slug: string;
+    interval?: string;
+    limit?: number;
+}
+declare function useCandlesticks(params: UseCandlesticksParams, queryOptions?: Omit<UseQueryOptions<Candlestick[], Error, Candlestick[], unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<Candlestick[], Error>;
+
+declare function positionsQueryKey(user: string, source?: ProviderSource): unknown[];
+interface UsePositionsParams {
+    /** Provider source. Omit to aggregate all providers. */
+    source?: ProviderSource;
+    user: string;
+}
+declare function usePositions(params: UsePositionsParams, queryOptions?: Omit<UseQueryOptions<PositionsResponse, Error, PositionsResponse, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<PositionsResponse, Error>;
+
+declare function balanceQueryKey(source: ProviderSource, user: string): unknown[];
+interface UseBalanceParams {
+    source: ProviderSource;
+    user: string;
+}
+declare function useBalance(params: UseBalanceParams, queryOptions?: Omit<UseQueryOptions<BalanceResponse, Error, BalanceResponse, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<BalanceResponse, Error>;
+
+declare function ordersQueryKey(params: ListOrdersParams): unknown[];
+declare function useOrders(params: ListOrdersParams, queryOptions?: Omit<UseQueryOptions<PredictPage<PredictOrder>, Error, PredictPage<PredictOrder>, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<PredictPage<PredictOrder>, Error>;
+
+declare function orderQueryKey(id: string, source: ProviderSource): unknown[];
+interface UseOrderParams {
+    id: string;
+    source: ProviderSource;
+}
+/**
+ * Query a single order by ID. Automatically polls every 1 s while enabled.
+ */
+declare function useOrder(params: UseOrderParams, queryOptions?: Omit<UseQueryOptions<PredictOrder, Error, PredictOrder, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<PredictOrder, Error>;
+
+interface CancelOrderVariables {
+    id: string;
+    source: ProviderSource;
+}
+declare function useCancelOrder(mutationOptions?: Omit<UseMutationOptions<CancelOrderResult, Error, CancelOrderVariables>, "mutationFn">): _tanstack_react_query.UseMutationResult<CancelOrderResult, Error, CancelOrderVariables, unknown>;
+
+declare function tradesQueryKey(params: ListTradesParams): unknown[];
+declare function useTrades(params: ListTradesParams, queryOptions?: Omit<UseQueryOptions<PredictPage<PredictTrade>, Error, PredictPage<PredictTrade>, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<PredictPage<PredictTrade>, Error>;
+
+declare function dflowQuoteQueryKey(params: DFlowQuoteRequest): unknown[];
+/**
+ * Fetch a DFlow quote. The query is only enabled when all required
+ * fields are present and amount > 0.
+ */
+declare function useDFlowQuote(params: DFlowQuoteRequest, queryOptions?: Omit<UseQueryOptions<DFlowQuoteResponse, Error, DFlowQuoteResponse, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<DFlowQuoteResponse, Error>;
+
+declare function useDFlowSubmit(mutationOptions?: Omit<UseMutationOptions<DFlowSubmitResponse, Error, DFlowSubmitRequest>, "mutationFn">): _tanstack_react_query.UseMutationResult<DFlowSubmitResponse, Error, DFlowSubmitRequest, unknown>;
+
+interface UsePredictWsClientResult {
+    /** The WebSocket client instance, or `null` if not provided via `PredictProvider`. */
+    wsClient: PredictWsClient | null;
+    /** Current connection status. Defaults to `"disconnected"` when no client. */
+    wsStatus: WsConnectionStatus;
+    /** Shorthand for `wsStatus === "connected"`. */
+    isWsConnected: boolean;
+}
+/**
+ * Access the `PredictWsClient` from context and track its connection status.
+ *
+ * Must be called inside a `PredictProvider`.
+ */
+declare function usePredictWsClient(): UsePredictWsClientResult;
+
+interface UsePricesSubscriptionParams {
+    /** WebSocket client (from `usePredictWsClient`). */
+    wsClient: PredictWsClient | null;
+    /** Market slugs to subscribe to. */
+    slugs: string[];
+    /** Enable/disable the subscription. Default: `true`. */
+    enabled?: boolean;
+    /** Optional callback fired on every price update. */
+    onUpdate?: (msg: WsDataMessage<WsPriceEvent>) => void;
+}
+interface UsePricesSubscriptionResult {
+    /** Latest price data keyed by market slug. */
+    prices: Map<string, WsPriceEvent>;
+    /** Whether the subscription is active. */
+    isSubscribed: boolean;
+}
+/**
+ * Subscribe to real-time price updates via WebSocket.
+ *
+ * Maintains an internal `Map<slug, WsPriceEvent>` that updates on each push.
+ * Does **not** interact with React Query.
+ */
+declare function usePricesSubscription({ wsClient, slugs, enabled, onUpdate, }: UsePricesSubscriptionParams): UsePricesSubscriptionResult;
+
+interface UseOrderbookSubscriptionParams {
+    /** WebSocket client (from `usePredictWsClient`). */
+    wsClient: PredictWsClient | null;
+    /** Market slug to subscribe to. */
+    slug: string;
+    /** Enable/disable the subscription. Default: `true`. */
+    enabled?: boolean;
+    /** Optional callback fired on every orderbook snapshot. */
+    onUpdate?: (msg: WsDataMessage<WsOrderbookEvent>) => void;
+}
+interface UseOrderbookSubscriptionResult {
+    /** Latest full orderbook snapshot, or `null` before the first push. */
+    orderbook: WsOrderbookEvent | null;
+    /** Whether the subscription is active. */
+    isSubscribed: boolean;
+}
+/**
+ * Subscribe to real-time orderbook snapshots via WebSocket.
+ *
+ * Each incoming message is a **full snapshot** — no delta merging needed.
+ * Does **not** interact with React Query.
+ */
+declare function useOrderbookSubscription({ wsClient, slug, enabled, onUpdate, }: UseOrderbookSubscriptionParams): UseOrderbookSubscriptionResult;
+
+interface UseTradesSubscriptionParams {
+    /** WebSocket client (from `usePredictWsClient`). */
+    wsClient: PredictWsClient | null;
+    /** Market slug to subscribe to. */
+    slug: string;
+    /** Enable/disable the subscription. Default: `true`. */
+    enabled?: boolean;
+    /** Max trades to keep in the buffer. Default: `100`. */
+    maxHistory?: number;
+    /** Optional callback fired on every new trade. */
+    onUpdate?: (msg: WsDataMessage<WsTradeEvent>) => void;
+}
+interface UseTradesSubscriptionResult {
+    /** Buffered trades, newest first. */
+    trades: WsTradeEvent[];
+    /** Whether the subscription is active. */
+    isSubscribed: boolean;
+    /** Clear the trade buffer. */
+    clearHistory: () => void;
+}
+/**
+ * Subscribe to real-time trade events via WebSocket.
+ *
+ * Maintains a bounded buffer of recent trades (newest first).
+ * Does **not** interact with React Query.
+ */
+declare function useTradesSubscription({ wsClient, slug, enabled, maxHistory, onUpdate, }: UseTradesSubscriptionParams): UseTradesSubscriptionResult;
+
+interface UseRealtimeOrderbookParams {
+    slug: string;
+    source: ProviderSource;
+}
+/**
+ * Orderbook with automatic WS → REST fallback.
+ *
+ * - When the WebSocket is subscribed, the hook writes incoming snapshots
+ *   directly into the React Query cache via `setQueryData` (no refetch)
+ *   and disables REST polling.
+ * - When the WebSocket is unavailable or disconnected, the hook falls
+ *   back to REST polling every 5 seconds.
+ *
+ * The return value is the same `UseQueryResult` as `useOrderbook`, so
+ * migrating from `useOrderbook` is a drop-in replacement.
+ */
+declare function useRealtimeOrderbook(params: UseRealtimeOrderbookParams, queryOptions?: Omit<UseQueryOptions<Orderbook, Error, Orderbook, unknown[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<Orderbook, Error>;
+
+interface UseRealtimePricesParams {
+    /** Market slugs to subscribe to. */
+    slugs: string[];
+    /** Enable/disable. Default: `true`. */
+    enabled?: boolean;
+    /** Optional callback on each price update. */
+    onUpdate?: (msg: WsDataMessage<WsPriceEvent>) => void;
+}
+/**
+ * Real-time price updates with graceful degradation.
+ *
+ * When the WebSocket client is available and connected, this hook
+ * subscribes to price updates and returns a `Map<slug, WsPriceEvent>`.
+ * When no WebSocket client is provided, `prices` stays empty and
+ * `isSubscribed` is `false` — the consumer can fall back to REST data.
+ */
+declare function useRealtimePrices({ slugs, enabled, onUpdate, }: UseRealtimePricesParams): UsePricesSubscriptionResult;
+
+interface UseRealtimeTradesParams {
+    /** Market slug to subscribe to. */
+    slug: string;
+    /** Enable/disable. Default: `true`. */
+    enabled?: boolean;
+    /** Max WS trades to buffer. Default: `100`. */
+    maxHistory?: number;
+    /** Optional callback on each new trade. */
+    onUpdate?: (msg: WsDataMessage<WsTradeEvent>) => void;
+    /**
+     * When `true`, new WS trades are prepended into matching React Query
+     * `marketTrades` cache entries so paginated lists update instantly.
+     * Default: `true`.
+     */
+    syncToQueryCache?: boolean;
+}
+type UseRealtimeTradesResult = UseTradesSubscriptionResult;
+/**
+ * Real-time trade stream with optional React Query cache sync.
+ *
+ * Subscribes to the `trades` WS channel for a single market.
+ * When `syncToQueryCache` is enabled (default), each new trade is also
+ * prepended into any active React Query cache entry whose key matches
+ * `["predict", "market-trades", slug, ...]`.
+ */
+declare function useRealtimeTrades({ slug, enabled, maxHistory, onUpdate, syncToQueryCache, }: UseRealtimeTradesParams): UseRealtimeTradesResult;
+
+/**
+ * Access Polymarket L2 credentials and authentication actions.
+ *
+ * Must be called inside a component tree wrapped by `PolymarketProvider`.
+ *
+ * @throws When used outside of `PolymarketProvider`.
+ *
+ * @example
+ * ```tsx
+ * function TradeButton() {
+ *   const { credentials, authenticate, isAuthenticating } = usePolymarket();
+ *
+ *   const handleClick = async () => {
+ *     if (!credentials) {
+ *       await authenticate(myPolymarketSigner);
+ *     }
+ *     // proceed to place order
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleClick} disabled={isAuthenticating}>
+ *       Trade
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function usePolymarket(): PolymarketContextValue;
+
+interface CreatePolymarketOrderVariables {
+    input: CreateOrderInput;
+    /**
+     * IoC signer — provided by the consuming app.
+     * Used to sign the EIP-712 order struct on the CTF Exchange contract.
+     */
+    signer: PolymarketSigner;
+}
+/**
+ * Mutation hook for creating a Polymarket limit order.
+ *
+ * Flow:
+ * 1. If no L2 credentials exist, triggers L1 → L2 authentication automatically.
+ * 2. Builds the EIP-712 `Order` typed data and prompts the wallet for a signature.
+ * 3. Constructs HMAC L2 auth headers from the stored credentials.
+ * 4. Submits the signed order via `POST /api/v1/orders/polymarket` (prediction-server proxy).
+ * 5. Invalidates `orders` and `positions` queries on success.
+ *
+ * @example
+ * ```tsx
+ * const { mutateAsync: createOrder, isPending } = useCreatePolymarketOrder();
+ *
+ * await createOrder({
+ *   signer: myPolymarketSigner,
+ *   input: {
+ *     tokenId: "123456789",
+ *     price: 0.55,
+ *     size: 10,
+ *     side: "BUY",
+ *     tickSize: "0.01",
+ *     negRisk: false,
+ *   },
+ * });
+ * ```
+ */
+declare function useCreatePolymarketOrder(mutationOptions?: Omit<UseMutationOptions<PredictOrder, Error, CreatePolymarketOrderVariables>, "mutationFn">): _tanstack_react_query.UseMutationResult<PredictOrder, Error, CreatePolymarketOrderVariables, unknown>;
+
+export { BalanceResponse, CancelOrderResult, type CancelOrderVariables, Candlestick, ChartRange, type ChartRangeType, CreateOrderInput, type CreatePolymarketOrderVariables, DFlowQuoteRequest, DFlowQuoteResponse, DFlowSubmitRequest, DFlowSubmitResponse, EventStatus, ListCandlesticksParams, ListEventsParams, ListMarketTradesParams, ListOrdersParams, ListTradesParams, type MarketHistoryPoint, type MarketHistorySeries, Orderbook, PolymarketContext, type PolymarketContextValue, type PolymarketCredentials, PolymarketProvider, type PolymarketProviderProps, type PolymarketSigner, PositionsResponse, PredictClient, PredictContext, type PredictContextValue, PredictEvent, PredictMarket, PredictOrder, PredictPage, PredictProvider, type PredictProviderProps, PredictTrade, PredictWsClient, PriceHistoryRange, PriceHistoryResponse, ProviderSource, SimilarEventsParams, type UseBalanceParams, type UseCandlesticksParams, type UseEventParams, type UseMarketHistoryResult, type UseMarketTradesParams, type UseOrderParams, type UseOrderbookParams, type UseOrderbookSubscriptionParams, type UseOrderbookSubscriptionResult, type UsePositionsParams, type UsePredictWsClientResult, type UsePriceHistoryParams, type UsePricesSubscriptionParams, type UsePricesSubscriptionResult, type UseRealtimeOrderbookParams, type UseRealtimePricesParams, type UseRealtimeTradesParams, type UseRealtimeTradesResult, type UseSearchEventsParams, type UseSimilarEventsParams, type UseTradesSubscriptionParams, type UseTradesSubscriptionResult, WsConnectionStatus, WsDataMessage, WsOrderbookEvent, WsPriceEvent, WsTradeEvent, balanceQueryKey, candlesticksQueryKey, dflowQuoteQueryKey, eventsQueryKey, fetchEvents, marketTradesQueryKey, orderQueryKey, orderbookQueryKey, ordersQueryKey, positionsQueryKey, priceHistoryQueryKey, similarEventsQueryKey, tradesQueryKey, useBalance, useCancelOrder, useCandlesticks, useCreatePolymarketOrder, useDFlowQuote, useDFlowSubmit, useEvent, useEvents, useInfiniteEvents, useMarketHistory, useMarketTrades, useOrder, useOrderbook, useOrderbookSubscription, useOrders, usePolymarket, usePositions, usePredictClient, usePredictWsClient, usePriceHistory, usePricesSubscription, useRealtimeOrderbook, useRealtimePrices, useRealtimeTrades, useSearchEvents, useSimilarEvents, useTrades, useTradesSubscription };