@limitless-exchange/sdk 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,3015 @@
+import { ethers } from 'ethers';
+import { AxiosRequestConfig, AxiosResponse } from 'axios';
+
+/**
+ * Client type for authentication.
+ * @public
+ */
+type ClientType = 'eoa' | 'base' | 'etherspot';
+/**
+ * Trading mode for user interface.
+ * @public
+ */
+type TradingMode = 'SIMPLE' | 'ADVANCED';
+/**
+ * Authentication headers required for login.
+ * @public
+ */
+interface SignatureHeaders {
+    /**
+     * The Ethereum address of the user
+     */
+    'x-account': string;
+    /**
+     * The signing message in hex format
+     */
+    'x-signing-message': string;
+    /**
+     * The signature generated by signing the message with the user's wallet
+     */
+    'x-signature': string;
+}
+/**
+ * User profile information returned after authentication.
+ * @public
+ */
+interface UserProfile {
+    /**
+     * User's Ethereum address (EOA)
+     */
+    account: string;
+    /**
+     * Display name for the user
+     */
+    displayName: string;
+    /**
+     * Smart wallet address (optional, required for ETHERSPOT client)
+     */
+    smartWallet?: string;
+    /**
+     * Client type used for authentication
+     */
+    client: ClientType;
+}
+/**
+ * Mode information from authentication response.
+ * @public
+ */
+interface ModeInfo {
+    /**
+     * Trading interface mode
+     */
+    mode: TradingMode;
+    /**
+     * Whether the user is new to the platform
+     */
+    isUserNew: boolean;
+}
+/**
+ * User data for order operations.
+ *
+ * @remarks
+ * Contains user-specific information needed for creating orders.
+ * Typically extracted from authentication result.
+ *
+ * @public
+ */
+interface UserData {
+    /**
+     * User ID (owner ID) from the API
+     */
+    userId: number;
+    /**
+     * Fee rate in basis points for this user
+     * Common values: 100 (1%), 200 (2%), 300 (3%)
+     */
+    feeRateBps: number;
+}
+/**
+ * Complete authentication result including session and profile.
+ * @public
+ */
+interface AuthResult {
+    /**
+     * Session cookie value (JWT token)
+     */
+    sessionCookie: string;
+    /**
+     * User profile information
+     */
+    profile: UserProfile;
+}
+/**
+ * Options for login authentication.
+ * @public
+ */
+interface LoginOptions {
+    /**
+     * Client type to use for authentication
+     * @defaultValue 'eoa'
+     */
+    client?: ClientType;
+    /**
+     * Smart wallet address (required when client is 'etherspot')
+     */
+    smartWallet?: string;
+}
+
+/**
+ * Logger interface for SDK integration.
+ * Allows users to inject their own logging implementation.
+ *
+ * @public
+ */
+interface ILogger {
+    /**
+     * Log debug information (verbose, development only)
+     */
+    debug(message: string, meta?: Record<string, any>): void;
+    /**
+     * Log informational messages
+     */
+    info(message: string, meta?: Record<string, any>): void;
+    /**
+     * Log warning messages
+     */
+    warn(message: string, meta?: Record<string, any>): void;
+    /**
+     * Log error messages
+     */
+    error(message: string, error?: Error, meta?: Record<string, any>): void;
+}
+/**
+ * No-op logger (default) - does nothing.
+ * Zero performance overhead when logging is not needed.
+ *
+ * @internal
+ */
+declare class NoOpLogger implements ILogger {
+    debug(): void;
+    info(): void;
+    warn(): void;
+    error(): void;
+}
+/**
+ * Simple console logger for development.
+ * Can be used as a starting point or for debugging.
+ *
+ * @example
+ * ```typescript
+ * import { ConsoleLogger } from '@limitless-exchange/sdk';
+ *
+ * const logger = new ConsoleLogger('debug');
+ * const authenticator = new Authenticator(httpClient, signer, logger);
+ * ```
+ *
+ * @public
+ */
+declare class ConsoleLogger implements ILogger {
+    private level;
+    constructor(level?: 'debug' | 'info' | 'warn' | 'error');
+    private shouldLog;
+    debug(message: string, meta?: Record<string, any>): void;
+    info(message: string, meta?: Record<string, any>): void;
+    warn(message: string, meta?: Record<string, any>): void;
+    error(message: string, error?: Error, meta?: Record<string, any>): void;
+}
+
+/**
+ * Order-related types for Limitless Exchange.
+ * @module types/orders
+ */
+/**
+ * Order side enum.
+ * @public
+ */
+declare enum Side {
+    BUY = 0,
+    SELL = 1
+}
+/**
+ * Order type enum.
+ * @public
+ */
+declare enum OrderType {
+    /** Fill-or-Kill: Execute immediately or cancel */
+    FOK = "FOK",
+    /** Good-Til-Cancelled: Remain on orderbook until filled or cancelled */
+    GTC = "GTC"
+}
+/**
+ * Market type enum.
+ * @public
+ */
+declare enum MarketType {
+    CLOB = "CLOB",
+    NEGRISK = "NEGRISK"
+}
+/**
+ * Signature type enum.
+ * @public
+ */
+declare enum SignatureType {
+    /** Externally Owned Account */
+    EOA = 0,
+    /** Polymarket Proxy */
+    POLY_PROXY = 1,
+    /** Polymarket Gnosis Safe */
+    POLY_GNOSIS_SAFE = 2
+}
+/**
+ * Base arguments shared by all order types.
+ * @public
+ */
+interface BaseOrderArgs {
+    /**
+     * Token ID for the outcome
+     */
+    tokenId: string;
+    /**
+     * Order side (BUY or SELL)
+     */
+    side: Side;
+    /**
+     * Market type (CLOB or NEGRISK)
+     * @defaultValue 'CLOB'
+     */
+    marketType?: MarketType;
+    /**
+     * Expiration timestamp (0 for no expiration)
+     * @defaultValue '0'
+     */
+    expiration?: string;
+    /**
+     * Nonce for order replay protection
+     * @defaultValue 0
+     */
+    nonce?: number;
+    /**
+     * Taker address (ZERO_ADDRESS for any taker)
+     * @defaultValue '0x0000000000000000000000000000000000000000'
+     */
+    taker?: string;
+}
+/**
+ * Arguments for FOK (Fill-or-Kill) market orders.
+ *
+ * @remarks
+ * FOK orders are market orders that execute immediately at the best available price.
+ * Specify the maker amount (human-readable, max 6 decimals).
+ *
+ * For BUY orders: Amount in USDC to spend (e.g., 50.0 = spend $50 USDC)
+ * For SELL orders: Number of shares to sell (e.g., 18.64 = sell 18.64 shares)
+ *
+ * @example
+ * ```typescript
+ * // BUY: Spend 50 USDC
+ * {
+ *   tokenId: '123...',
+ *   makerAmount: 50,      // Spend $50 USDC
+ *   side: Side.BUY
+ * }
+ *
+ * // SELL: Sell 18.64 shares
+ * {
+ *   tokenId: '123...',
+ *   makerAmount: 18.64,   // Sell 18.64 shares
+ *   side: Side.SELL
+ * }
+ * ```
+ *
+ * @public
+ */
+interface FOKOrderArgs extends BaseOrderArgs {
+    /**
+     * Maker amount (human-readable, max 6 decimals)
+     *
+     * For BUY orders: Amount of USDC to spend
+     * For SELL orders: Number of shares to sell
+     *
+     * @example
+     * // BUY examples
+     * 50 = Spend $50 USDC
+     * 1.5 = Spend $1.50 USDC
+     * 0.75 = Spend $0.75 USDC
+     *
+     * // SELL examples
+     * 18.64 = Sell 18.64 shares
+     * 44.111 = Sell 44.111 shares
+     */
+    makerAmount: number;
+}
+/**
+ * Arguments for GTC (Good-Til-Cancelled) limit orders.
+ *
+ * @remarks
+ * GTC orders are limit orders that remain on the orderbook until filled or cancelled.
+ * You specify the price and number of shares.
+ *
+ * @example
+ * ```typescript
+ * // BUY: Buy 10 shares at 0.65 price
+ * {
+ *   tokenId: '123...',
+ *   price: 0.65,
+ *   size: 10,
+ *   side: Side.BUY
+ * }
+ *
+ * // SELL: Sell 5 shares at 0.75 price
+ * {
+ *   tokenId: '123...',
+ *   price: 0.75,
+ *   size: 5,
+ *   side: Side.SELL
+ * }
+ * ```
+ *
+ * @public
+ */
+interface GTCOrderArgs extends BaseOrderArgs {
+    /**
+     * Price per share (0.0 to 1.0)
+     */
+    price: number;
+    /**
+     * Number of shares to trade
+     */
+    size: number;
+}
+/**
+ * Union type for all order arguments.
+ * @public
+ */
+type OrderArgs = FOKOrderArgs | GTCOrderArgs;
+/**
+ * Unsigned order payload.
+ * @public
+ */
+interface UnsignedOrder {
+    /**
+     * Unique salt for order identification
+     */
+    salt: number;
+    /**
+     * Maker address (order creator)
+     */
+    maker: string;
+    /**
+     * Signer address (must match maker for EOA)
+     */
+    signer: string;
+    /**
+     * Taker address (ZERO_ADDRESS for any taker)
+     */
+    taker: string;
+    /**
+     * Token ID for the outcome
+     */
+    tokenId: string;
+    /**
+     * Maker amount in USDC units (6 decimals)
+     */
+    makerAmount: number;
+    /**
+     * Taker amount in USDC units (6 decimals)
+     */
+    takerAmount: number;
+    /**
+     * Expiration timestamp (0 for no expiration)
+     */
+    expiration: string;
+    /**
+     * Nonce for replay protection
+     */
+    nonce: number;
+    /**
+     * Fee rate in basis points
+     */
+    feeRateBps: number;
+    /**
+     * Order side (BUY or SELL)
+     */
+    side: Side;
+    /**
+     * Signature type (EOA, POLY_PROXY, etc.)
+     */
+    signatureType: SignatureType;
+    /**
+     * Price per share (required for GTC orders)
+     */
+    price?: number;
+}
+/**
+ * Signed order payload.
+ * @public
+ */
+interface SignedOrder extends UnsignedOrder {
+    /**
+     * EIP-712 signature
+     */
+    signature: string;
+}
+/**
+ * Complete order payload for API submission.
+ * @public
+ */
+interface NewOrderPayload {
+    /**
+     * Signed order details
+     */
+    order: SignedOrder;
+    /**
+     * Order type (FOK or GTC)
+     */
+    orderType: OrderType;
+    /**
+     * Market slug identifier
+     */
+    marketSlug: string;
+    /**
+     * Owner ID from user profile
+     */
+    ownerId: number;
+}
+/**
+ * Clean order data returned from API.
+ *
+ * @remarks
+ * This is a minimal, user-friendly representation of an order
+ * that excludes unnecessary API metadata.
+ *
+ * @public
+ */
+interface CreatedOrder {
+    /**
+     * Order database ID
+     */
+    id: string;
+    /**
+     * Creation timestamp (ISO 8601)
+     */
+    createdAt: string;
+    /**
+     * Maker amount (USDC units with 6 decimals)
+     */
+    makerAmount: number;
+    /**
+     * Taker amount (USDC units with 6 decimals)
+     */
+    takerAmount: number;
+    /**
+     * Expiration timestamp (null for no expiration)
+     */
+    expiration: string | null;
+    /**
+     * Signature type (0 = EOA, 1 = Polymarket Proxy, 2 = Gnosis Safe)
+     */
+    signatureType: number;
+    /**
+     * Unique salt for order identification
+     */
+    salt: number;
+    /**
+     * Maker address
+     */
+    maker: string;
+    /**
+     * Signer address
+     */
+    signer: string;
+    /**
+     * Taker address (zero address for any taker)
+     */
+    taker: string;
+    /**
+     * Token ID for the outcome
+     */
+    tokenId: string;
+    /**
+     * Order side (0 = BUY, 1 = SELL)
+     */
+    side: Side;
+    /**
+     * Fee rate in basis points
+     */
+    feeRateBps: number;
+    /**
+     * Nonce for replay protection
+     */
+    nonce: number;
+    /**
+     * EIP-712 signature
+     */
+    signature: string;
+    /**
+     * Order type (GTC or FOK)
+     */
+    orderType: string;
+    /**
+     * Price per share (0.0 to 1.0) - only for GTC orders
+     */
+    price: number | null;
+    /**
+     * Market database ID
+     */
+    marketId: number;
+}
+/**
+ * Match information for filled orders.
+ *
+ * @remarks
+ * When a FOK order is filled or a GTC order is partially matched,
+ * this provides minimal information about the match.
+ *
+ * @public
+ */
+interface OrderMatch {
+    /**
+     * Match database ID
+     */
+    id: string;
+    /**
+     * Creation timestamp (ISO 8601)
+     */
+    createdAt: string;
+    /**
+     * Matched size (USDC units with 6 decimals)
+     */
+    matchedSize: string;
+    /**
+     * Matched order ID
+     */
+    orderId: string;
+}
+/**
+ * Clean order creation response.
+ *
+ * @remarks
+ * This is what users receive after successfully creating an order.
+ * For GTC orders, makerMatches will be undefined or empty.
+ * For FOK orders, makerMatches contains the fills.
+ *
+ * @public
+ */
+interface OrderResponse {
+    /**
+     * Created order data
+     */
+    order: CreatedOrder;
+    /**
+     * Matches if order was filled (FOK) or partially matched (GTC)
+     */
+    makerMatches?: OrderMatch[];
+}
+/**
+ * Order signing configuration.
+ * @public
+ */
+interface OrderSigningConfig {
+    /**
+     * Blockchain chain ID
+     */
+    chainId: number;
+    /**
+     * Contract address for verification
+     */
+    contractAddress: string;
+    /**
+     * Market type (CLOB or NEGRISK)
+     */
+    marketType: MarketType;
+}
+
+/**
+ * Market-related types for Limitless Exchange.
+ * @module types/markets
+ */
+/**
+ * Orderbook entry (bid or ask).
+ * @public
+ */
+interface OrderbookEntry {
+    /**
+     * Price per share
+     */
+    price: number;
+    /**
+     * Size in shares (scaled by 1e6)
+     */
+    size: number;
+    /**
+     * Order side (BUY or SELL)
+     */
+    side: string;
+}
+/**
+ * Complete orderbook for a market.
+ * @public
+ */
+interface OrderBook {
+    /**
+     * Bid orders (buy orders)
+     */
+    bids: OrderbookEntry[];
+    /**
+     * Ask orders (sell orders)
+     */
+    asks: OrderbookEntry[];
+    /**
+     * Token ID for the orderbook (YES token)
+     */
+    tokenId: string;
+    /**
+     * Minimum order size
+     */
+    minSize: string;
+    /**
+     * Last trade price
+     */
+    lastTradePrice?: number;
+}
+/**
+ * Market price information.
+ * @public
+ */
+interface MarketPrice {
+    /**
+     * Token ID
+     */
+    tokenId: string;
+    /**
+     * Current price
+     */
+    price: number;
+    /**
+     * Last update timestamp
+     */
+    updatedAt?: string;
+}
+/**
+ * Market outcome information.
+ * @public
+ */
+interface MarketOutcome {
+    /**
+     * Outcome ID
+     */
+    id: number;
+    /**
+     * Outcome title
+     */
+    title: string;
+    /**
+     * Token ID for this outcome
+     */
+    tokenId: string;
+    /**
+     * Current price
+     */
+    price?: number;
+}
+/**
+ * Complete market information.
+ * @public
+ */
+interface Market {
+    /**
+     * Market database ID
+     */
+    id: number;
+    /**
+     * Market contract address
+     */
+    address: string | null;
+    /**
+     * Market title
+     */
+    title: string;
+    /**
+     * Market proxy title
+     */
+    proxyTitle: string | null;
+    /**
+     * Market description
+     */
+    description: string;
+    /**
+     * Market slug identifier
+     */
+    slug: string;
+    /**
+     * Market type (CLOB or AMM)
+     */
+    type?: string;
+    /**
+     * Market outcomes
+     */
+    outcomes?: MarketOutcome[];
+    /**
+     * Creation timestamp
+     */
+    createdAt: string;
+    /**
+     * Last update timestamp
+     */
+    updatedAt: string;
+    /**
+     * Market status
+     */
+    status?: string;
+    /**
+     * Resolution timestamp
+     */
+    resolutionDate?: string;
+}
+/**
+ * Markets list response.
+ * @public
+ */
+interface MarketsResponse {
+    /**
+     * Array of markets
+     */
+    markets: Market[];
+    /**
+     * Total count
+     */
+    total?: number;
+    /**
+     * Pagination offset
+     */
+    offset?: number;
+    /**
+     * Pagination limit
+     */
+    limit?: number;
+}
+/**
+ * Sort options for active markets.
+ * @public
+ */
+type ActiveMarketsSortBy = 'lp_rewards' | 'ending_soon' | 'newest' | 'high_value';
+/**
+ * Query parameters for active markets endpoint.
+ * @public
+ */
+interface ActiveMarketsParams {
+    /**
+     * Maximum number of markets to return (max 25)
+     * @defaultValue 25
+     */
+    limit?: number;
+    /**
+     * Page number for pagination (starts at 1)
+     * @defaultValue 1
+     */
+    page?: number;
+    /**
+     * Sort order for markets
+     */
+    sortBy?: ActiveMarketsSortBy;
+}
+/**
+ * Active markets response from API.
+ * @public
+ */
+interface ActiveMarketsResponse {
+    /**
+     * Array of active markets
+     */
+    data: Market[];
+    /**
+     * Total count of active markets
+     */
+    totalMarketsCount: number;
+}
+
+/**
+ * Portfolio and position types for Limitless Exchange.
+ * @module types/portfolio
+ */
+/**
+ * Market information for a position.
+ *
+ * @public
+ */
+interface PositionMarket {
+    /**
+     * Market ID
+     */
+    id: number | string;
+    /**
+     * Market slug
+     */
+    slug: string;
+    /**
+     * Market title
+     */
+    title: string;
+    /**
+     * Market status
+     */
+    status?: string;
+    /**
+     * Whether market is closed
+     */
+    closed: boolean;
+    /**
+     * Market deadline
+     */
+    deadline: string;
+    /**
+     * Condition ID
+     */
+    conditionId?: string;
+    /**
+     * Winning outcome index (null if unresolved)
+     */
+    winningOutcomeIndex?: number | null;
+    /**
+     * Market group information
+     */
+    group?: {
+        slug?: string;
+        title?: string;
+    };
+}
+/**
+ * Position details for YES or NO side.
+ *
+ * @public
+ */
+interface PositionSide {
+    /**
+     * Cost basis (6 decimals)
+     */
+    cost: string;
+    /**
+     * Fill price (6 decimals for CLOB, decimal string for AMM)
+     */
+    fillPrice: string;
+    /**
+     * Current market value (6 decimals)
+     */
+    marketValue: string;
+    /**
+     * Realized P&L (6 decimals)
+     */
+    realisedPnl: string;
+    /**
+     * Unrealized P&L (6 decimals)
+     */
+    unrealizedPnl: string;
+}
+/**
+ * Token balance for YES or NO side.
+ *
+ * @public
+ */
+interface TokenBalance {
+    /**
+     * YES token balance (6 decimals)
+     */
+    yes: string;
+    /**
+     * NO token balance (6 decimals)
+     */
+    no: string;
+}
+/**
+ * Latest trade information.
+ *
+ * @public
+ */
+interface LatestTrade {
+    /**
+     * Latest YES price (0.0 to 1.0)
+     */
+    latestYesPrice: number;
+    /**
+     * Latest NO price (0.0 to 1.0)
+     */
+    latestNoPrice: number;
+    /**
+     * Outcome token price (0.0 to 1.0)
+     */
+    outcomeTokenPrice: number;
+}
+/**
+ * CLOB (Central Limit Order Book) position.
+ *
+ * @public
+ */
+interface CLOBPosition {
+    /**
+     * Market information
+     */
+    market: PositionMarket;
+    /**
+     * User's wallet address
+     */
+    makerAddress: string;
+    /**
+     * Position details for YES and NO sides
+     */
+    positions: {
+        yes: PositionSide;
+        no: PositionSide;
+    };
+    /**
+     * Token balances
+     */
+    tokensBalance: TokenBalance;
+    /**
+     * Latest trade information
+     */
+    latestTrade: LatestTrade;
+    /**
+     * Active orders information
+     */
+    orders?: {
+        liveOrders: any[];
+        totalCollateralLocked: string;
+    };
+    /**
+     * Rewards information
+     */
+    rewards?: {
+        epochs: any[];
+        isEarning: boolean;
+    };
+}
+/**
+ * AMM (Automated Market Maker) position.
+ *
+ * @public
+ */
+interface AMMPosition {
+    /**
+     * Market information
+     */
+    market: PositionMarket;
+    /**
+     * User's wallet address
+     */
+    account: string;
+    /**
+     * Outcome index (0 for YES, 1 for NO)
+     */
+    outcomeIndex: number;
+    /**
+     * Collateral amount (decimal string)
+     */
+    collateralAmount: string;
+    /**
+     * Outcome token amount (decimal string)
+     */
+    outcomeTokenAmount: string;
+    /**
+     * Average fill price (decimal string)
+     */
+    averageFillPrice: string;
+    /**
+     * Total buys cost (decimal string)
+     */
+    totalBuysCost: string;
+    /**
+     * Total sells cost (decimal string)
+     */
+    totalSellsCost: string;
+    /**
+     * Realized P&L (decimal string)
+     */
+    realizedPnl: string;
+    /**
+     * Unrealized P&L (decimal string)
+     */
+    unrealizedPnl: string;
+    /**
+     * Latest trade information
+     */
+    latestTrade?: {
+        outcomeTokenPrice: string;
+    };
+}
+/**
+ * API response for /portfolio/positions endpoint.
+ *
+ * @public
+ */
+interface PortfolioPositionsResponse {
+    /**
+     * AMM positions
+     */
+    amm: AMMPosition[];
+    /**
+     * CLOB positions
+     */
+    clob: CLOBPosition[];
+    /**
+     * Group positions
+     */
+    group: any[];
+    /**
+     * User points
+     */
+    points?: string;
+    /**
+     * Accumulative points
+     */
+    accumulativePoints?: string;
+    /**
+     * Rewards information
+     */
+    rewards?: {
+        todaysRewards: string;
+        rewardsByEpoch: any[];
+        rewardsChartData: any[];
+        totalUnpaidRewards: string;
+        totalUserRewardsLastEpoch: string;
+    };
+}
+/**
+ * Simplified position for unified view.
+ *
+ * @public
+ */
+interface Position {
+    /**
+     * Position type
+     */
+    type: 'CLOB' | 'AMM';
+    /**
+     * Market information
+     */
+    market: PositionMarket;
+    /**
+     * Position side (YES or NO)
+     */
+    side: 'YES' | 'NO';
+    /**
+     * Cost basis in USDC (6 decimals)
+     */
+    costBasis: number;
+    /**
+     * Current market value in USDC (6 decimals)
+     */
+    marketValue: number;
+    /**
+     * Unrealized P&L in USDC (6 decimals)
+     */
+    unrealizedPnl: number;
+    /**
+     * Realized P&L in USDC (6 decimals)
+     */
+    realizedPnl: number;
+    /**
+     * Current price (0.0 to 1.0)
+     */
+    currentPrice: number;
+    /**
+     * Average entry price (0.0 to 1.0)
+     */
+    avgPrice: number;
+    /**
+     * Token balance (6 decimals)
+     */
+    tokenBalance: number;
+}
+/**
+ * Portfolio summary statistics.
+ *
+ * @public
+ */
+interface PortfolioSummary {
+    /**
+     * Total portfolio value in USDC (6 decimals)
+     */
+    totalValue: number;
+    /**
+     * Total cost basis in USDC (6 decimals)
+     */
+    totalCostBasis: number;
+    /**
+     * Total unrealized P&L in USDC (6 decimals)
+     */
+    totalUnrealizedPnl: number;
+    /**
+     * Total realized P&L in USDC (6 decimals)
+     */
+    totalRealizedPnl: number;
+    /**
+     * Total unrealized P&L percentage
+     */
+    totalUnrealizedPnlPercent: number;
+    /**
+     * Number of open positions
+     */
+    positionCount: number;
+    /**
+     * Number of markets with positions
+     */
+    marketCount: number;
+    /**
+     * Breakdown by position type
+     */
+    breakdown: {
+        clob: {
+            positions: number;
+            value: number;
+            pnl: number;
+        };
+        amm: {
+            positions: number;
+            value: number;
+            pnl: number;
+        };
+    };
+}
+
+/**
+ * WebSocket types for real-time data streaming.
+ * @module types/websocket
+ */
+/**
+ * WebSocket connection configuration.
+ * @public
+ */
+interface WebSocketConfig {
+    /**
+     * WebSocket URL (default: wss://ws.limitless.exchange)
+     */
+    url?: string;
+    /**
+     * Session cookie for authentication
+     */
+    sessionCookie?: string;
+    /**
+     * Auto-reconnect on connection loss (default: true)
+     */
+    autoReconnect?: boolean;
+    /**
+     * Reconnection delay in ms (default: 1000)
+     */
+    reconnectDelay?: number;
+    /**
+     * Maximum reconnection attempts (default: Infinity)
+     */
+    maxReconnectAttempts?: number;
+    /**
+     * Connection timeout in ms (default: 10000)
+     */
+    timeout?: number;
+}
+/**
+ * WebSocket connection state.
+ * @public
+ */
+declare enum WebSocketState {
+    DISCONNECTED = "disconnected",
+    CONNECTING = "connecting",
+    CONNECTED = "connected",
+    RECONNECTING = "reconnecting",
+    ERROR = "error"
+}
+/**
+ * Subscription channels for WebSocket events.
+ * @public
+ */
+type SubscriptionChannel = 'orderbook' | 'trades' | 'orders' | 'fills' | 'markets' | 'prices';
+/**
+ * Orderbook update event.
+ * @public
+ */
+interface OrderbookUpdate {
+    marketSlug: string;
+    bids: Array<{
+        price: number;
+        size: number;
+    }>;
+    asks: Array<{
+        price: number;
+        size: number;
+    }>;
+    timestamp: number;
+}
+/**
+ * Trade event.
+ * @public
+ */
+interface TradeEvent {
+    marketSlug: string;
+    side: 'BUY' | 'SELL';
+    price: number;
+    size: number;
+    timestamp: number;
+    tradeId: string;
+}
+/**
+ * Order update event.
+ * @public
+ */
+interface OrderUpdate {
+    orderId: string;
+    marketSlug: string;
+    side: 'BUY' | 'SELL';
+    price?: number;
+    size: number;
+    filled: number;
+    status: 'OPEN' | 'FILLED' | 'CANCELLED' | 'PARTIALLY_FILLED';
+    timestamp: number;
+}
+/**
+ * Order fill event.
+ * @public
+ */
+interface FillEvent {
+    orderId: string;
+    marketSlug: string;
+    side: 'BUY' | 'SELL';
+    price: number;
+    size: number;
+    timestamp: number;
+    fillId: string;
+}
+/**
+ * Market update event.
+ * @public
+ */
+interface MarketUpdate {
+    marketSlug: string;
+    lastPrice?: number;
+    volume24h?: number;
+    priceChange24h?: number;
+    timestamp: number;
+}
+/**
+ * Price update event.
+ * @public
+ */
+interface PriceUpdate {
+    marketSlug: string;
+    price: number;
+    timestamp: number;
+}
+/**
+ * WebSocket event types.
+ * @public
+ */
+interface WebSocketEvents {
+    /**
+     * Connection established
+     */
+    connect: () => void;
+    /**
+     * Connection lost
+     */
+    disconnect: (reason: string) => void;
+    /**
+     * Connection error
+     */
+    error: (error: Error) => void;
+    /**
+     * Reconnection attempt
+     */
+    reconnecting: (attempt: number) => void;
+    /**
+     * Orderbook updates
+     */
+    orderbook: (data: OrderbookUpdate) => void;
+    /**
+     * Trade events
+     */
+    trade: (data: TradeEvent) => void;
+    /**
+     * Order updates
+     */
+    order: (data: OrderUpdate) => void;
+    /**
+     * Order fill events
+     */
+    fill: (data: FillEvent) => void;
+    /**
+     * Market updates
+     */
+    market: (data: MarketUpdate) => void;
+    /**
+     * Price updates
+     */
+    price: (data: PriceUpdate) => void;
+}
+/**
+ * Subscription options.
+ * @public
+ */
+interface SubscriptionOptions {
+    /**
+     * Market slug to subscribe to (required for market-specific channels)
+     */
+    marketSlug?: string;
+    /**
+     * Market address to subscribe to (for AMM markets)
+     */
+    marketAddress?: string;
+    /**
+     * Additional filters
+     */
+    filters?: Record<string, any>;
+}
+
+/**
+ * Message signer for authentication.
+ *
+ * @remarks
+ * This class handles signing messages with an Ethereum wallet and
+ * creating authentication headers required by the Limitless Exchange API.
+ *
+ * @public
+ */
+declare class MessageSigner {
+    private wallet;
+    /**
+     * Creates a new message signer instance.
+     *
+     * @param wallet - Ethers wallet instance for signing
+     */
+    constructor(wallet: ethers.Wallet);
+    /**
+     * Creates authentication headers for API requests.
+     *
+     * @param signingMessage - Message to sign from the API
+     * @returns Promise resolving to signature headers
+     *
+     * @example
+     * ```typescript
+     * const signer = new MessageSigner(wallet);
+     * const headers = await signer.createAuthHeaders(message);
+     * ```
+     */
+    createAuthHeaders(signingMessage: string): Promise<SignatureHeaders>;
+    /**
+     * Signs EIP-712 typed data.
+     *
+     * @param domain - EIP-712 domain
+     * @param types - EIP-712 types
+     * @param value - Value to sign
+     * @returns Promise resolving to signature string
+     *
+     * @example
+     * ```typescript
+     * const signature = await signer.signTypedData(domain, types, order);
+     * ```
+     */
+    signTypedData(domain: ethers.TypedDataDomain, types: Record<string, ethers.TypedDataField[]>, value: Record<string, any>): Promise<string>;
+    /**
+     * Gets the wallet address.
+     *
+     * @returns Ethereum address
+     */
+    getAddress(): string;
+    /**
+     * Converts a string to hex format.
+     *
+     * @param text - String to convert
+     * @returns Hex string with 0x prefix
+     * @internal
+     */
+    private stringToHex;
+}
+
+/**
+ * Configuration options for the HTTP client.
+ * @public
+ */
+interface HttpClientConfig {
+    /**
+     * Base URL for API requests
+     * @defaultValue 'https://api.limitless.exchange'
+     */
+    baseURL?: string;
+    /**
+     * Request timeout in milliseconds
+     * @defaultValue 30000
+     */
+    timeout?: number;
+    /**
+     * Session cookie for authenticated requests
+     */
+    sessionCookie?: string;
+    /**
+     * Optional logger for debugging
+     * @defaultValue NoOpLogger (no logging)
+     */
+    logger?: ILogger;
+}
+/**
+ * HTTP client wrapper for Limitless Exchange API.
+ *
+ * @remarks
+ * This class provides a centralized HTTP client with cookie management,
+ * error handling, and request/response interceptors.
+ *
+ * @public
+ */
+declare class HttpClient {
+    private client;
+    private sessionCookie?;
+    private logger;
+    /**
+     * Creates a new HTTP client instance.
+     *
+     * @param config - Configuration options for the HTTP client
+     */
+    constructor(config?: HttpClientConfig);
+    /**
+     * Sets up request and response interceptors.
+     * @internal
+     */
+    private setupInterceptors;
+    /**
+     * Sets the session cookie for authenticated requests.
+     *
+     * @param cookie - Session cookie value
+     */
+    setSessionCookie(cookie: string): void;
+    /**
+     * Clears the session cookie.
+     */
+    clearSessionCookie(): void;
+    /**
+     * Performs a GET request.
+     *
+     * @param url - Request URL
+     * @param config - Additional request configuration
+     * @returns Promise resolving to the response data
+     */
+    get<T = any>(url: string, config?: AxiosRequestConfig): Promise<T>;
+    /**
+     * Performs a POST request.
+     *
+     * @param url - Request URL
+     * @param data - Request body data
+     * @param config - Additional request configuration
+     * @returns Promise resolving to the response data
+     */
+    post<T = any>(url: string, data?: any, config?: AxiosRequestConfig): Promise<T>;
+    /**
+     * Performs a POST request and returns the full response object.
+     * Useful when you need access to response headers (e.g., for cookie extraction).
+     *
+     * @param url - Request URL
+     * @param data - Request body data
+     * @param config - Additional request configuration
+     * @returns Promise resolving to the full AxiosResponse object
+     * @internal
+     */
+    postWithResponse<T = any>(url: string, data?: any, config?: AxiosRequestConfig): Promise<AxiosResponse<T>>;
+    /**
+     * Performs a DELETE request.
+     *
+     * @remarks
+     * DELETE requests typically don't have a body, so we remove the Content-Type header
+     * to avoid "Body cannot be empty" errors from the API.
+     *
+     * @param url - Request URL
+     * @param config - Additional request configuration
+     * @returns Promise resolving to the response data
+     */
+    delete<T = any>(url: string, config?: AxiosRequestConfig): Promise<T>;
+    /**
+     * Extracts cookies from response headers.
+     *
+     * @param response - Axios response object
+     * @returns Object containing parsed cookies
+     * @internal
+     */
+    extractCookies(response: AxiosResponse): Record<string, string>;
+}
+
+/**
+ * Authenticator for Limitless Exchange API.
+ *
+ * @remarks
+ * This class handles the complete authentication flow:
+ * 1. Get signing message from API
+ * 2. Sign message with wallet
+ * 3. Login and obtain session cookie
+ * 4. Verify authentication status
+ *
+ * @public
+ */
+declare class Authenticator {
+    private httpClient;
+    private signer;
+    private logger;
+    /**
+     * Creates a new authenticator instance.
+     *
+     * @param httpClient - HTTP client for API requests
+     * @param signer - Message signer for wallet operations
+     * @param logger - Optional logger for debugging and monitoring (default: no logging)
+     *
+     * @example
+     * ```typescript
+     * // Without logging (default)
+     * const authenticator = new Authenticator(httpClient, signer);
+     *
+     * // With logging
+     * import { ConsoleLogger } from '@limitless-exchange/sdk';
+     * const logger = new ConsoleLogger('debug');
+     * const authenticator = new Authenticator(httpClient, signer, logger);
+     * ```
+     */
+    constructor(httpClient: HttpClient, signer: MessageSigner, logger?: ILogger);
+    /**
+     * Gets a signing message from the API.
+     *
+     * @returns Promise resolving to signing message string
+     * @throws Error if API request fails
+     *
+     * @example
+     * ```typescript
+     * const message = await authenticator.getSigningMessage();
+     * console.log(message);
+     * ```
+     */
+    getSigningMessage(): Promise<string>;
+    /**
+     * Authenticates with the API and obtains session cookie.
+     *
+     * @param options - Login options including client type and smart wallet
+     * @returns Promise resolving to authentication result
+     * @throws Error if authentication fails or smart wallet is required but not provided
+     *
+     * @example
+     * ```typescript
+     * // EOA authentication
+     * const result = await authenticator.authenticate({ client: 'eoa' });
+     *
+     * // ETHERSPOT with smart wallet
+     * const result = await authenticator.authenticate({
+     *   client: 'etherspot',
+     *   smartWallet: '0x...'
+     * });
+     * ```
+     */
+    authenticate(options?: LoginOptions): Promise<AuthResult>;
+    /**
+     * Verifies the current authentication status.
+     *
+     * @param sessionCookie - Session cookie to verify
+     * @returns Promise resolving to user's Ethereum address
+     * @throws Error if session is invalid
+     *
+     * @example
+     * ```typescript
+     * const address = await authenticator.verifyAuth(sessionCookie);
+     * console.log(`Authenticated as: ${address}`);
+     * ```
+     */
+    verifyAuth(sessionCookie: string): Promise<string>;
+    /**
+     * Logs out and clears the session.
+     *
+     * @param sessionCookie - Session cookie to invalidate
+     * @throws Error if logout request fails
+     *
+     * @example
+     * ```typescript
+     * await authenticator.logout(sessionCookie);
+     * console.log('Logged out successfully');
+     * ```
+     */
+    logout(sessionCookie: string): Promise<void>;
+}
+
+/**
+ * Optional helper for automatic authentication retry on token expiration.
+ * @module auth/authenticated-client
+ */
+
+/**
+ * Configuration for authenticated client with auto-retry.
+ * @public
+ */
+interface AuthenticatedClientConfig {
+    /**
+     * HTTP client instance
+     */
+    httpClient: HttpClient;
+    /**
+     * Authenticator instance
+     */
+    authenticator: Authenticator;
+    /**
+     * Authentication client type ('eoa' or 'etherspot')
+     */
+    client: 'eoa' | 'etherspot';
+    /**
+     * Optional smart wallet address (required for 'etherspot')
+     */
+    smartWallet?: string;
+    /**
+     * Optional logger for debugging
+     */
+    logger?: ILogger;
+    /**
+     * Maximum retry attempts for auth errors (default: 1)
+     */
+    maxRetries?: number;
+}
+/**
+ * Optional helper class that automatically re-authenticates on token expiration.
+ *
+ * @remarks
+ * This is an optional convenience wrapper. Users can choose to handle
+ * authentication retry manually or use this helper for automatic retry logic.
+ *
+ * @example
+ * ```typescript
+ * // Create authenticated client with auto-retry
+ * const authClient = new AuthenticatedClient({
+ *   httpClient,
+ *   authenticator,
+ *   client: 'eoa'
+ * });
+ *
+ * // Use withRetry for automatic re-authentication
+ * const portfolioFetcher = new PortfolioFetcher(httpClient);
+ * const positions = await authClient.withRetry(() =>
+ *   portfolioFetcher.getPositions()
+ * );
+ * ```
+ *
+ * @public
+ */
+declare class AuthenticatedClient {
+    private httpClient;
+    private authenticator;
+    private client;
+    private smartWallet?;
+    private logger;
+    private maxRetries;
+    /**
+     * Creates a new authenticated client with auto-retry capability.
+     *
+     * @param config - Configuration for authenticated client
+     */
+    constructor(config: AuthenticatedClientConfig);
+    /**
+     * Executes a function with automatic retry on authentication errors.
+     *
+     * @param fn - Function to execute with auth retry
+     * @returns Promise resolving to the function result
+     * @throws Error if max retries exceeded or non-auth error occurs
+     *
+     * @example
+     * ```typescript
+     * // Automatic retry on 401/403
+     * const positions = await authClient.withRetry(() =>
+     *   portfolioFetcher.getPositions()
+     * );
+     *
+     * // Works with any async operation
+     * const order = await authClient.withRetry(() =>
+     *   orderClient.createOrder({ ... })
+     * );
+     * ```
+     */
+    withRetry<T>(fn: () => Promise<T>): Promise<T>;
+    /**
+     * Re-authenticates with the API.
+     *
+     * @internal
+     */
+    private reauthenticate;
+}
+
+/**
+ * API error types for Limitless Exchange SDK.
+ * @module api/errors
+ */
+/**
+ * Custom error class for API errors that preserves the original response data.
+ *
+ * @remarks
+ * This error class allows users to access the raw API response for custom error handling.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await orderClient.createOrder(...);
+ * } catch (error) {
+ *   if (error instanceof APIError) {
+ *     console.log('Status:', error.status);
+ *     console.log('Raw response:', error.data);
+ *     console.log('Message:', error.message);
+ *   }
+ * }
+ * ```
+ *
+ * @public
+ */
+declare class APIError extends Error {
+    /**
+     * HTTP status code (e.g., 400, 404, 500)
+     */
+    readonly status: number;
+    /**
+     * Raw API response data (original JSON from API)
+     */
+    readonly data: any;
+    /**
+     * Request URL that failed
+     */
+    readonly url?: string;
+    /**
+     * Request method (GET, POST, etc.)
+     */
+    readonly method?: string;
+    /**
+     * Creates a new API error.
+     *
+     * @param message - Human-readable error message
+     * @param status - HTTP status code
+     * @param data - Raw API response data
+     * @param url - Request URL
+     * @param method - Request method
+     */
+    constructor(message: string, status: number, data: any, url?: string, method?: string);
+    /**
+     * Checks if this error is an authentication/authorization error.
+     *
+     * @returns True if the error is due to expired or invalid authentication
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   await portfolioFetcher.getPositions();
+     * } catch (error) {
+     *   if (error instanceof APIError && error.isAuthError()) {
+     *     // Re-authenticate and retry
+     *     await authenticator.authenticate({ client: 'eoa' });
+     *     await portfolioFetcher.getPositions();
+     *   }
+     * }
+     * ```
+     */
+    isAuthError(): boolean;
+}
+
+/**
+ * Retry mechanism for handling transient API failures.
+ *
+ * @remarks
+ * This module provides flexible retry logic for handling rate limits (429),
+ * server errors (500, 502, 503), and other transient failures.
+ *
+ * @example
+ * ```typescript
+ * // Decorator approach
+ * @retryOnErrors({ statusCodes: [429, 500], maxRetries: 3, delays: [2, 5, 10] })
+ * async function createOrder() {
+ *   return await orderClient.createOrder(...);
+ * }
+ *
+ * // Wrapper approach
+ * const retryConfig = new RetryConfig({ statusCodes: [429, 500], maxRetries: 3 });
+ * const retryableClient = new RetryableClient(httpClient, retryConfig);
+ * const markets = await retryableClient.get('/markets');
+ * ```
+ *
+ * @module api/retry
+ * @public
+ */
+
+/**
+ * Configuration options for retry behavior.
+ *
+ * @public
+ */
+interface RetryConfigOptions {
+    /**
+     * HTTP status codes to retry on
+     * @defaultValue [429, 500, 502, 503, 504]
+     */
+    statusCodes?: number[];
+    /**
+     * Maximum number of retry attempts
+     * @defaultValue 3
+     */
+    maxRetries?: number;
+    /**
+     * List of delays in seconds for each retry attempt.
+     * If not provided, exponential backoff will be used.
+     * @defaultValue undefined (use exponential backoff)
+     */
+    delays?: number[];
+    /**
+     * Base for exponential backoff calculation (delay = base^attempt)
+     * @defaultValue 2
+     */
+    exponentialBase?: number;
+    /**
+     * Maximum delay in seconds for exponential backoff
+     * @defaultValue 60
+     */
+    maxDelay?: number;
+    /**
+     * Optional callback called before each retry attempt
+     * @param attempt - Retry attempt number (0-based)
+     * @param error - The error that triggered the retry
+     * @param delay - Delay in seconds before retry
+     */
+    onRetry?: (attempt: number, error: Error, delay: number) => void;
+}
+/**
+ * Configuration class for retry behavior.
+ *
+ * @public
+ */
+declare class RetryConfig {
+    /**
+     * HTTP status codes to retry on
+     */
+    readonly statusCodes: Set<number>;
+    /**
+     * Maximum number of retry attempts
+     */
+    readonly maxRetries: number;
+    /**
+     * List of delays in seconds for each retry
+     */
+    readonly delays?: number[];
+    /**
+     * Base for exponential backoff
+     */
+    readonly exponentialBase: number;
+    /**
+     * Maximum delay in seconds
+     */
+    readonly maxDelay: number;
+    /**
+     * Optional retry callback
+     */
+    readonly onRetry?: (attempt: number, error: Error, delay: number) => void;
+    /**
+     * Creates a new retry configuration.
+     *
+     * @param options - Configuration options
+     */
+    constructor(options?: RetryConfigOptions);
+    /**
+     * Calculates delay for a given retry attempt.
+     *
+     * @param attempt - Retry attempt number (0-based)
+     * @returns Delay in seconds
+     */
+    getDelay(attempt: number): number;
+}
+/**
+ * Decorator to add retry logic to async functions.
+ *
+ * @remarks
+ * This decorator automatically retries failed API calls based on HTTP status codes.
+ * Useful for handling transient errors like rate limits (429) or server errors (500, 502, 503).
+ *
+ * @param options - Retry configuration options
+ * @returns Method decorator
+ *
+ * @example
+ * ```typescript
+ * class MyService {
+ *   @retryOnErrors({ statusCodes: [429, 500], maxRetries: 3, delays: [2, 5, 10] })
+ *   async createOrder() {
+ *     return await this.orderClient.createOrder(...);
+ *   }
+ * }
+ * ```
+ *
+ * @public
+ */
+declare function retryOnErrors(options?: RetryConfigOptions): (_target: any, _propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+/**
+ * Standalone retry function for wrapping async operations.
+ *
+ * @remarks
+ * This function wraps any async operation with retry logic.
+ * More flexible than the decorator approach for one-off retries.
+ *
+ * @param fn - Async function to execute with retry
+ * @param options - Retry configuration options
+ * @param logger - Optional logger for retry information
+ * @returns Promise resolving to the function result
+ *
+ * @example
+ * ```typescript
+ * const result = await withRetry(
+ *   async () => await orderClient.createOrder(...),
+ *   { statusCodes: [429, 500], maxRetries: 3, delays: [2, 5, 10] }
+ * );
+ * ```
+ *
+ * @public
+ */
+declare function withRetry<T>(fn: () => Promise<T>, options?: RetryConfigOptions, logger?: ILogger): Promise<T>;
+/**
+ * HTTP client wrapper that adds retry logic to all requests.
+ *
+ * @remarks
+ * This class wraps an HttpClient and automatically retries failed requests
+ * based on configured retry settings.
+ *
+ * @example
+ * ```typescript
+ * const httpClient = new HttpClient({ logger });
+ * const retryConfig = new RetryConfig({ statusCodes: [429, 500], maxRetries: 3 });
+ * const retryableClient = new RetryableClient(httpClient, retryConfig);
+ *
+ * // All requests automatically retry on 429, 500
+ * const markets = await retryableClient.get('/markets');
+ * ```
+ *
+ * @public
+ */
+declare class RetryableClient {
+    private httpClient;
+    private retryConfig;
+    private logger;
+    /**
+     * Creates a new retryable client wrapper.
+     *
+     * @param httpClient - HTTP client to wrap
+     * @param retryConfig - Retry configuration
+     * @param logger - Optional logger
+     */
+    constructor(httpClient: any, retryConfig?: RetryConfig, logger?: ILogger);
+    /**
+     * Performs a GET request with retry logic.
+     *
+     * @param url - Request URL
+     * @param config - Additional request configuration
+     * @returns Promise resolving to the response data
+     */
+    get<T = any>(url: string, config?: any): Promise<T>;
+    /**
+     * Performs a POST request with retry logic.
+     *
+     * @param url - Request URL
+     * @param data - Request body data
+     * @param config - Additional request configuration
+     * @returns Promise resolving to the response data
+     */
+    post<T = any>(url: string, data?: any, config?: any): Promise<T>;
+    /**
+     * Performs a DELETE request with retry logic.
+     *
+     * @param url - Request URL
+     * @param config - Additional request configuration
+     * @returns Promise resolving to the response data
+     */
+    delete<T = any>(url: string, config?: any): Promise<T>;
+    /**
+     * Forwards any other method calls to the wrapped HTTP client.
+     *
+     * @param method - Method name
+     */
+    [key: string]: any;
+}
+
+/**
+ * Default API endpoints and configuration constants.
+ * @public
+ */
+/**
+ * Default Limitless Exchange API URL.
+ * @public
+ */
+declare const DEFAULT_API_URL = "https://api.limitless.exchange";
+/**
+ * Default WebSocket URL for real-time data.
+ * @public
+ */
+declare const DEFAULT_WS_URL = "wss://ws.limitless.exchange";
+/**
+ * Default chain ID (Base mainnet).
+ * @public
+ */
+declare const DEFAULT_CHAIN_ID = 8453;
+/**
+ * Base Sepolia testnet chain ID.
+ * @public
+ */
+declare const BASE_SEPOLIA_CHAIN_ID = 84532;
+/**
+ * Signing message template used by the API.
+ * @internal
+ */
+declare const SIGNING_MESSAGE_TEMPLATE = "Welcome to Limitless.exchange! Please sign this message to verify your identity.\n\nNonce: {NONCE}";
+/**
+ * Zero address constant.
+ * @public
+ */
+declare const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+/**
+ * Contract addresses by network
+ * @public
+ */
+declare const CONTRACT_ADDRESSES: {
+    readonly 8453: {
+        readonly CLOB: "0xa4409D988CA2218d956BeEFD3874100F444f0DC3";
+        readonly NEGRISK: "0x5a38afc17F7E97ad8d6C547ddb837E40B4aEDfC6";
+    };
+    readonly 84532: {
+        readonly CLOB: "0x...";
+        readonly NEGRISK: "0x...";
+    };
+};
+/**
+ * Get contract address for a specific market type and chain
+ *
+ * @param marketType - Market type (CLOB or NEGRISK)
+ * @param chainId - Chain ID (default: 8453 for Base mainnet)
+ * @returns Contract address
+ *
+ * @throws Error if contract address not found for chain
+ *
+ * @public
+ */
+declare function getContractAddress(marketType: 'CLOB' | 'NEGRISK', chainId?: number): string;
+
+/**
+ * Order builder for constructing unsigned order payloads.
+ * @module orders/builder
+ */
+
+/**
+ * Order builder for constructing unsigned order payloads.
+ *
+ * @remarks
+ * This class handles the construction of unsigned orders matching the
+ * Limitless Exchange API format. It generates unique salts, calculates
+ * maker/taker amounts with proper tick alignment, and validates inputs.
+ *
+ * **Tick Alignment Requirements**:
+ * - Prices must align to tick size (default: 0.001 = 3 decimals)
+ * - Size must produce takerAmount divisible by sharesStep (priceScale / tickInt = 1000 for 0.001 tick)
+ * - SDK validates inputs and throws clear errors rather than auto-rounding
+ * - This ensures `price * contracts` yields whole number collateral
+ *
+ * **Validation Strategy**:
+ * - FAILS FAST: Invalid inputs throw errors with helpful suggestions
+ * - NO AUTO-ROUNDING: Users maintain full control over order amounts
+ * - TRANSPARENCY: Error messages show valid alternatives
+ * - Example: size=22.123896 → Error: "Try 22.123 (rounded down) or 22.124 (rounded up) instead"
+ *
+ * @public
+ */
+declare class OrderBuilder {
+    private makerAddress;
+    private feeRateBps;
+    private priceTick;
+    /**
+     * Creates a new order builder instance.
+     *
+     * @param makerAddress - Ethereum address of the order maker
+     * @param feeRateBps - Fee rate in basis points (e.g., 100 = 1%)
+     * @param priceTick - Price tick size (default: 0.001 for 3 decimals)
+     *
+     * @example
+     * ```typescript
+     * const builder = new OrderBuilder(
+     *   '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb',
+     *   300, // 3% fee
+     *   0.001 // 3 decimal price precision
+     * );
+     * ```
+     */
+    constructor(makerAddress: string, feeRateBps: number, priceTick?: number);
+    /**
+     * Builds an unsigned order payload.
+     *
+     * @param args - Order arguments (FOK or GTC)
+     * @returns Unsigned order ready for signing
+     *
+     * @throws Error if validation fails or tick alignment fails
+     *
+     * @example
+     * ```typescript
+     * // FOK order (market order)
+     * const fokOrder = builder.buildOrder({
+     *   tokenId: '123456',
+     *   makerAmount: 50,  // 50 USDC to spend
+     *   side: Side.BUY,
+     *   marketType: MarketType.CLOB
+     * });
+     *
+     * // GTC order (price + size)
+     * const gtcOrder = builder.buildOrder({
+     *   tokenId: '123456',
+     *   price: 0.38,
+     *   size: 22.123,  // Will be rounded to tick-aligned: 22.123 shares
+     *   side: Side.BUY,
+     *   marketType: MarketType.CLOB
+     * });
+     * ```
+     */
+    buildOrder(args: OrderArgs): UnsignedOrder;
+    /**
+     * Type guard to check if order arguments are for FOK order.
+     *
+     * @param args - Order arguments
+     * @returns True if FOK order arguments
+     *
+     * @internal
+     */
+    private isFOKOrder;
+    /**
+     * Generates a unique salt using timestamp + nano-offset pattern.
+     *
+     * @remarks
+     * This follows the reference implementation pattern:
+     * salt = timestamp * 1000 + nanoOffset + 24h
+     *
+     * This ensures uniqueness even when creating orders rapidly.
+     *
+     * @returns Unique salt value
+     *
+     * @internal
+     */
+    private generateSalt;
+    /**
+     * Parses decimal string to scaled BigInt.
+     *
+     * @param value - Decimal string (e.g., "0.38")
+     * @param scale - Scale factor (e.g., 1_000_000n for 6 decimals)
+     * @returns Scaled BigInt value
+     *
+     * @internal
+     */
+    private parseDecToInt;
+    /**
+     * Ceiling division for BigInt.
+     *
+     * @param numerator - Numerator
+     * @param denominator - Denominator
+     * @returns Ceiling of numerator / denominator
+     *
+     * @internal
+     */
+    private divCeil;
+    /**
+     * Calculates maker and taker amounts for GTC orders with tick alignment validation.
+     *
+     * @remarks
+     * Validates and calculates amounts to ensure:
+     * 1. Price aligns to tick size (e.g., 0.001 for 3 decimals)
+     * 2. Size produces takerAmount divisible by sharesStep
+     * 3. No auto-rounding - fails fast if values are invalid
+     * 4. Transparent error messages guide users to valid values
+     *
+     * **Algorithm**:
+     * - sharesStep = priceScale / tickInt (e.g., 1000 for 0.001 tick)
+     * - Validates shares are divisible by sharesStep
+     * - Calculates collateral from shares × price (ceil for BUY, floor for SELL)
+     * - Assigns maker/taker based on side:
+     *   - BUY: maker = collateral, taker = shares
+     *   - SELL: maker = shares, taker = collateral
+     * - Throws clear error if size is not tick-aligned
+     *
+     * @param price - Price per share (0.0 to 1.0, max 3 decimals)
+     * @param size - Number of shares (must be tick-aligned)
+     * @param side - Order side (BUY or SELL)
+     * @returns Object with validated makerAmount, takerAmount, and price
+     *
+     * @throws Error if price or size not tick-aligned
+     *
+     * @internal
+     */
+    private calculateGTCAmountsTickAligned;
+    /**
+     * Calculates maker and taker amounts for FOK (market) orders.
+     *
+     * @remarks
+     * FOK orders use makerAmount for both BUY and SELL:
+     * - BUY: makerAmount = USDC amount to spend (e.g., 50 = $50 USDC)
+     * - SELL: makerAmount = number of shares to sell (e.g., 18.64 shares)
+     *
+     * takerAmount is always 1 (constant for FOK orders)
+     *
+     * @param makerAmount - Amount in human-readable format (max 6 decimals)
+     * @returns Object with makerAmount (scaled), takerAmount (always 1), and undefined price
+     *
+     * @internal
+     */
+    private calculateFOKAmounts;
+    /**
+     * Validates order arguments.
+     *
+     * @param args - Order arguments to validate
+     * @throws Error if validation fails
+     *
+     * @internal
+     */
+    private validateOrderArgs;
+}
+
+/**
+ * EIP-712 order signer for Limitless Exchange.
+ * @module orders/signer
+ */
+
+/**
+ * EIP-712 order signer.
+ *
+ * @remarks
+ * This class handles EIP-712 signing for Limitless Exchange orders.
+ * It creates signatures that match the API's verification requirements.
+ *
+ * Domain: "Limitless CTF Exchange"
+ * Version: "1"
+ *
+ * @public
+ */
+declare class OrderSigner {
+    private wallet;
+    private logger;
+    /**
+     * Creates a new order signer instance.
+     *
+     * @param wallet - Ethers wallet for signing
+     * @param logger - Optional logger for debugging (default: no logging)
+     *
+     * @example
+     * ```typescript
+     * import { ethers } from 'ethers';
+     * import { OrderSigner } from '@limitless-exchange/sdk';
+     *
+     * const wallet = new ethers.Wallet(privateKey);
+     * const signer = new OrderSigner(wallet);
+     * ```
+     */
+    constructor(wallet: ethers.Wallet, logger?: ILogger);
+    /**
+     * Signs an order with EIP-712.
+     *
+     * @param order - Unsigned order to sign
+     * @param config - Signing configuration (chainId, contract address, market type)
+     * @returns Promise resolving to EIP-712 signature
+     *
+     * @throws Error if wallet address doesn't match order signer
+     * @throws Error if signing fails
+     *
+     * @example
+     * ```typescript
+     * const signature = await signer.signOrder(unsignedOrder, {
+     *   chainId: 8453,
+     *   contractAddress: '0x...',
+     *   marketType: MarketType.CLOB
+     * });
+     * ```
+     */
+    signOrder(order: UnsignedOrder, config: OrderSigningConfig): Promise<string>;
+    /**
+     * Gets the EIP-712 domain for signing.
+     *
+     * @param config - Signing configuration
+     * @returns EIP-712 domain object
+     *
+     * @internal
+     */
+    private getDomain;
+    /**
+     * Gets the EIP-712 type definitions.
+     *
+     * @remarks
+     * This matches the order structure expected by the Limitless Exchange
+     * smart contracts.
+     *
+     * @returns EIP-712 types definition
+     *
+     * @internal
+     */
+    private getTypes;
+}
+
+/**
+ * Order validation utilities.
+ * @module orders/validator
+ */
+
+/**
+ * Validation error class.
+ * @public
+ */
+declare class ValidationError extends Error {
+    constructor(message: string);
+}
+/**
+ * Validates order arguments before building.
+ *
+ * @param args - Order arguments to validate (FOK or GTC)
+ * @throws ValidationError if validation fails
+ *
+ * @public
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   validateOrderArgs(orderArgs);
+ * } catch (error) {
+ *   console.error('Validation failed:', error.message);
+ * }
+ * ```
+ */
+declare function validateOrderArgs(args: OrderArgs): void;
+/**
+ * Validates an unsigned order.
+ *
+ * @param order - Unsigned order to validate
+ * @throws ValidationError if validation fails
+ *
+ * @public
+ *
+ * @example
+ * ```typescript
+ * validateUnsignedOrder(unsignedOrder);
+ * ```
+ */
+declare function validateUnsignedOrder(order: UnsignedOrder): void;
+/**
+ * Validates a signed order.
+ *
+ * @param order - Signed order to validate
+ * @throws ValidationError if validation fails
+ *
+ * @public
+ *
+ * @example
+ * ```typescript
+ * validateSignedOrder(signedOrder);
+ * ```
+ */
+declare function validateSignedOrder(order: SignedOrder): void;
+
+/**
+ * Order client for managing orders on Limitless Exchange.
+ * @module orders/client
+ */
+
+/**
+ * Configuration for the order client.
+ *
+ * @remarks
+ * The order client supports two configuration modes:
+ * 1. Simple mode: Provide userData and marketType (auto-configures signing)
+ * 2. Advanced mode: Provide userData and custom signingConfig
+ *
+ * @public
+ */
+interface OrderClientConfig {
+    /**
+     * HTTP client for API requests
+     */
+    httpClient: HttpClient;
+    /**
+     * Wallet for signing orders
+     */
+    wallet: ethers.Wallet;
+    /**
+     * User data containing userId and feeRateBps
+     *
+     * @example
+     * ```typescript
+     * {
+     *   userId: 123,      // From auth result
+     *   feeRateBps: 300   // User's fee rate (3%)
+     * }
+     * ```
+     */
+    userData: UserData;
+    /**
+     * Market type for auto-configuration (optional if signingConfig provided)
+     *
+     * @remarks
+     * When provided without signingConfig, automatically loads contract address
+     * from environment variables or SDK defaults.
+     *
+     * @defaultValue MarketType.CLOB
+     */
+    marketType?: MarketType;
+    /**
+     * Custom signing configuration (optional)
+     *
+     * @remarks
+     * If not provided, SDK will auto-configure based on marketType.
+     * Useful for custom deployments or testing.
+     */
+    signingConfig?: OrderSigningConfig;
+    /**
+     * Optional logger
+     */
+    logger?: ILogger;
+}
+/**
+ * Order client for creating and managing orders.
+ *
+ * @remarks
+ * This class provides high-level methods for order operations,
+ * abstracting away HTTP details and order signing complexity.
+ *
+ * @example
+ * ```typescript
+ * const orderClient = new OrderClient({
+ *   httpClient,
+ *   wallet,
+ *   ownerId: 123,
+ *   feeRateBps: 100,
+ *   signingConfig: {
+ *     chainId: 8453,
+ *     contractAddress: '0x...',
+ *     marketType: MarketType.CLOB
+ *   }
+ * });
+ *
+ * const order = await orderClient.createOrder({
+ *   tokenId: '123...',
+ *   price: 0.65,
+ *   size: 100,
+ *   side: Side.BUY,
+ *   orderType: OrderType.GTC,
+ *   marketSlug: 'market-slug'
+ * });
+ * ```
+ *
+ * @public
+ */
+declare class OrderClient {
+    private httpClient;
+    private orderBuilder;
+    private orderSigner;
+    private ownerId;
+    private signingConfig;
+    private logger;
+    /**
+     * Creates a new order client instance.
+     *
+     * @param config - Order client configuration
+     *
+     * @throws Error if neither marketType nor signingConfig is provided
+     */
+    constructor(config: OrderClientConfig);
+    /**
+     * Creates and submits a new order.
+     *
+     * @remarks
+     * This method handles the complete order creation flow:
+     * 1. Build unsigned order
+     * 2. Sign with EIP-712
+     * 3. Submit to API
+     *
+     * @param params - Order parameters
+     * @returns Promise resolving to order response
+     *
+     * @throws Error if order creation fails
+     *
+     * @example
+     * ```typescript
+     * const order = await orderClient.createOrder({
+     *   tokenId: '123456',
+     *   price: 0.65,
+     *   size: 100,
+     *   side: Side.BUY,
+     *   orderType: OrderType.GTC,
+     *   marketSlug: 'market-slug'
+     * });
+     *
+     * console.log(`Order created: ${order.order.id}`);
+     * ```
+     */
+    createOrder(params: OrderArgs & {
+        orderType: OrderType;
+        marketSlug: string;
+    }): Promise<OrderResponse>;
+    /**
+     * Transforms raw API response to clean OrderResponse DTO.
+     *
+     * @param apiResponse - Raw API response with nested objects
+     * @returns Clean OrderResponse with only essential fields
+     *
+     * @internal
+     */
+    private transformOrderResponse;
+    /**
+     * Cancels an existing order by ID.
+     *
+     * @param orderId - Order ID to cancel
+     * @returns Promise resolving to cancellation message
+     *
+     * @throws Error if cancellation fails
+     *
+     * @example
+     * ```typescript
+     * const result = await orderClient.cancel('order-id-123');
+     * console.log(result.message); // "Order canceled successfully"
+     * ```
+     */
+    cancel(orderId: string): Promise<{
+        message: string;
+    }>;
+    /**
+     * Cancels all orders for a specific market.
+     *
+     * @param marketSlug - Market slug to cancel all orders for
+     * @returns Promise resolving to cancellation message
+     *
+     * @throws Error if cancellation fails
+     *
+     * @example
+     * ```typescript
+     * const result = await orderClient.cancelAll('market-slug-123');
+     * console.log(result.message); // "Orders canceled successfully"
+     * ```
+     */
+    cancelAll(marketSlug: string): Promise<{
+        message: string;
+    }>;
+    /**
+     * @deprecated Use `cancel()` instead
+     */
+    cancelOrder(orderId: string): Promise<void>;
+    /**
+     * Gets an order by ID.
+     *
+     * @param orderId - Order ID to fetch
+     * @returns Promise resolving to order details
+     *
+     * @throws Error if order not found
+     *
+     * @example
+     * ```typescript
+     * const order = await orderClient.getOrder('order-id-123');
+     * console.log(order.order.side);
+     * ```
+     */
+    getOrder(orderId: string): Promise<OrderResponse>;
+    /**
+     * Builds an unsigned order without submitting.
+     *
+     * @remarks
+     * Useful for advanced use cases where you need the unsigned order
+     * before signing and submission.
+     *
+     * @param params - Order parameters
+     * @returns Unsigned order
+     *
+     * @example
+     * ```typescript
+     * const unsignedOrder = orderClient.buildUnsignedOrder({
+     *   tokenId: '123456',
+     *   price: 0.65,
+     *   size: 100,
+     *   side: Side.BUY
+     * });
+     * ```
+     */
+    buildUnsignedOrder(params: OrderArgs): UnsignedOrder;
+    /**
+     * Signs an unsigned order without submitting.
+     *
+     * @remarks
+     * Useful for advanced use cases where you need to inspect
+     * the signature before submission.
+     *
+     * @param order - Unsigned order to sign
+     * @returns Promise resolving to signature
+     *
+     * @example
+     * ```typescript
+     * const signature = await orderClient.signOrder(unsignedOrder);
+     * ```
+     */
+    signOrder(order: UnsignedOrder): Promise<string>;
+}
+
+/**
+ * Market data fetcher for Limitless Exchange.
+ * @module markets/fetcher
+ */
+
+/**
+ * Market data fetcher for retrieving market information and orderbooks.
+ *
+ * @remarks
+ * This class provides methods to fetch market data, orderbooks, and prices
+ * from the Limitless Exchange API.
+ *
+ * @public
+ */
+declare class MarketFetcher {
+    private httpClient;
+    private logger;
+    /**
+     * Creates a new market fetcher instance.
+     *
+     * @param httpClient - HTTP client for API requests
+     * @param logger - Optional logger for debugging (default: no logging)
+     *
+     * @example
+     * ```typescript
+     * const fetcher = new MarketFetcher(httpClient);
+     * ```
+     */
+    constructor(httpClient: HttpClient, logger?: ILogger);
+    /**
+     * Gets active markets with query parameters and pagination support.
+     *
+     * @param params - Query parameters for filtering and pagination
+     * @returns Promise resolving to active markets response
+     * @throws Error if API request fails
+     *
+     * @example
+     * ```typescript
+     * // Get 8 markets sorted by LP rewards
+     * const response = await fetcher.getActiveMarkets({
+     *   limit: 8,
+     *   sortBy: 'lp_rewards'
+     * });
+     * console.log(`Found ${response.data.length} of ${response.totalMarketsCount} markets`);
+     *
+     * // Get page 2
+     * const page2 = await fetcher.getActiveMarkets({
+     *   limit: 8,
+     *   page: 2,
+     *   sortBy: 'ending_soon'
+     * });
+     * ```
+     */
+    getActiveMarkets(params?: ActiveMarketsParams): Promise<ActiveMarketsResponse>;
+    /**
+     * Gets a single market by slug.
+     *
+     * @param slug - Market slug identifier
+     * @returns Promise resolving to market details
+     * @throws Error if API request fails or market not found
+     *
+     * @example
+     * ```typescript
+     * const market = await fetcher.getMarket('bitcoin-price-2024');
+     * console.log(`Market: ${market.title}`);
+     * ```
+     */
+    getMarket(slug: string): Promise<Market>;
+    /**
+     * Gets the orderbook for a CLOB market.
+     *
+     * @param slug - Market slug identifier
+     * @returns Promise resolving to orderbook data
+     * @throws Error if API request fails
+     *
+     * @example
+     * ```typescript
+     * const orderbook = await fetcher.getOrderBook('bitcoin-price-2024');
+     * console.log(`Bids: ${orderbook.bids.length}, Asks: ${orderbook.asks.length}`);
+     * ```
+     */
+    getOrderBook(slug: string): Promise<OrderBook>;
+    /**
+     * Gets the current price for a token.
+     *
+     * @param tokenId - Token ID
+     * @returns Promise resolving to price information
+     * @throws Error if API request fails
+     *
+     * @example
+     * ```typescript
+     * const price = await fetcher.getPrice('123456');
+     * console.log(`Current price: ${price.price}`);
+     * ```
+     */
+    getPrice(tokenId: string): Promise<MarketPrice>;
+}
+
+/**
+ * Portfolio data fetcher for Limitless Exchange.
+ * @module portfolio/fetcher
+ */
+
+/**
+ * Portfolio data fetcher for retrieving user positions and portfolio information.
+ *
+ * @remarks
+ * This class provides methods to fetch user positions and calculate portfolio statistics
+ * from the Limitless Exchange API. Requires an authenticated HttpClient.
+ *
+ * @public
+ */
+declare class PortfolioFetcher {
+    private httpClient;
+    private logger;
+    /**
+     * Creates a new portfolio fetcher instance.
+     *
+     * @param httpClient - Authenticated HTTP client for API requests
+     * @param logger - Optional logger for debugging (default: no logging)
+     *
+     * @example
+     * ```typescript
+     * // Create authenticated client
+     * const httpClient = new HttpClient({ baseURL: API_URL });
+     * await authenticator.authenticate({ client: 'eoa' });
+     *
+     * // Create portfolio fetcher
+     * const portfolioFetcher = new PortfolioFetcher(httpClient);
+     * ```
+     */
+    constructor(httpClient: HttpClient, logger?: ILogger);
+    /**
+     * Gets raw portfolio positions response from API.
+     *
+     * @returns Promise resolving to portfolio positions response with CLOB and AMM positions
+     * @throws Error if API request fails or user is not authenticated
+     *
+     * @example
+     * ```typescript
+     * const response = await portfolioFetcher.getPositions();
+     * console.log(`CLOB positions: ${response.clob.length}`);
+     * console.log(`AMM positions: ${response.amm.length}`);
+     * console.log(`Total points: ${response.accumulativePoints}`);
+     * ```
+     */
+    getPositions(): Promise<PortfolioPositionsResponse>;
+    /**
+     * Gets CLOB positions only.
+     *
+     * @returns Promise resolving to array of CLOB positions
+     * @throws Error if API request fails
+     *
+     * @example
+     * ```typescript
+     * const clobPositions = await portfolioFetcher.getCLOBPositions();
+     * clobPositions.forEach(pos => {
+     *   console.log(`${pos.market.title}: YES ${pos.positions.yes.unrealizedPnl} P&L`);
+     * });
+     * ```
+     */
+    getCLOBPositions(): Promise<CLOBPosition[]>;
+    /**
+     * Gets AMM positions only.
+     *
+     * @returns Promise resolving to array of AMM positions
+     * @throws Error if API request fails
+     *
+     * @example
+     * ```typescript
+     * const ammPositions = await portfolioFetcher.getAMMPositions();
+     * ammPositions.forEach(pos => {
+     *   console.log(`${pos.market.title}: ${pos.unrealizedPnl} P&L`);
+     * });
+     * ```
+     */
+    getAMMPositions(): Promise<AMMPosition[]>;
+    /**
+     * Flattens positions into a unified format for easier consumption.
+     *
+     * @remarks
+     * Converts CLOB positions (which have YES/NO sides) and AMM positions
+     * into a unified Position array. Only includes positions with non-zero values.
+     *
+     * @returns Promise resolving to array of flattened positions
+     * @throws Error if API request fails
+     *
+     * @example
+     * ```typescript
+     * const positions = await portfolioFetcher.getFlattenedPositions();
+     * positions.forEach(pos => {
+     *   const pnlPercent = (pos.unrealizedPnl / pos.costBasis) * 100;
+     *   console.log(`${pos.market.title} (${pos.side}): ${pnlPercent.toFixed(2)}% P&L`);
+     * });
+     * ```
+     */
+    getFlattenedPositions(): Promise<Position[]>;
+    /**
+     * Calculates portfolio summary statistics from raw API response.
+     *
+     * @param response - Portfolio positions response from API
+     * @returns Portfolio summary with totals and statistics
+     *
+     * @example
+     * ```typescript
+     * const response = await portfolioFetcher.getPositions();
+     * const summary = portfolioFetcher.calculateSummary(response);
+     *
+     * console.log(`Total Portfolio Value: $${(summary.totalValue / 1e6).toFixed(2)}`);
+     * console.log(`Total P&L: ${summary.totalUnrealizedPnlPercent.toFixed(2)}%`);
+     * console.log(`CLOB Positions: ${summary.breakdown.clob.positions}`);
+     * console.log(`AMM Positions: ${summary.breakdown.amm.positions}`);
+     * ```
+     */
+    calculateSummary(response: PortfolioPositionsResponse): PortfolioSummary;
+    /**
+     * Gets positions and calculates summary in a single call.
+     *
+     * @returns Promise resolving to response and summary
+     * @throws Error if API request fails or user is not authenticated
+     *
+     * @example
+     * ```typescript
+     * const { response, summary } = await portfolioFetcher.getPortfolio();
+     *
+     * console.log('Portfolio Summary:');
+     * console.log(`  Total Value: $${(summary.totalValue / 1e6).toFixed(2)}`);
+     * console.log(`  Total P&L: $${(summary.totalUnrealizedPnl / 1e6).toFixed(2)}`);
+     * console.log(`  P&L %: ${summary.totalUnrealizedPnlPercent.toFixed(2)}%`);
+     * console.log(`\nCLOB Positions: ${response.clob.length}`);
+     * console.log(`AMM Positions: ${response.amm.length}`);
+     * ```
+     */
+    getPortfolio(): Promise<{
+        response: PortfolioPositionsResponse;
+        summary: PortfolioSummary;
+    }>;
+}
+
+/**
+ * WebSocket client for real-time data streaming.
+ * @module websocket/client
+ */
+
+/**
+ * WebSocket client for real-time data streaming from Limitless Exchange.
+ *
+ * @remarks
+ * This client uses Socket.IO to connect to the WebSocket server and provides
+ * typed event subscriptions for orderbook, trades, orders, and market data.
+ *
+ * @example
+ * ```typescript
+ * // Create client
+ * const wsClient = new WebSocketClient({
+ *   sessionCookie: 'your-session-cookie',
+ *   autoReconnect: true,
+ * });
+ *
+ * // Subscribe to orderbook updates
+ * wsClient.on('orderbook', (data) => {
+ *   console.log('Orderbook update:', data);
+ * });
+ *
+ * // Connect and subscribe
+ * await wsClient.connect();
+ * await wsClient.subscribe('orderbook', { marketSlug: 'market-123' });
+ * ```
+ *
+ * @public
+ */
+declare class WebSocketClient {
+    private socket;
+    private config;
+    private logger;
+    private state;
+    private reconnectAttempts;
+    private subscriptions;
+    private pendingListeners;
+    /**
+     * Creates a new WebSocket client.
+     *
+     * @param config - WebSocket configuration
+     * @param logger - Optional logger for debugging
+     */
+    constructor(config?: WebSocketConfig, logger?: ILogger);
+    /**
+     * Gets current connection state.
+     *
+     * @returns Current WebSocket state
+     */
+    getState(): WebSocketState;
+    /**
+     * Checks if client is connected.
+     *
+     * @returns True if connected
+     */
+    isConnected(): boolean;
+    /**
+     * Sets the session cookie for authentication.
+     *
+     * @param sessionCookie - Session cookie value
+     */
+    setSessionCookie(sessionCookie: string): void;
+    /**
+     * Connects to the WebSocket server.
+     *
+     * @returns Promise that resolves when connected
+     * @throws Error if connection fails
+     *
+     * @example
+     * ```typescript
+     * await wsClient.connect();
+     * console.log('Connected!');
+     * ```
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnects from the WebSocket server.
+     *
+     * @example
+     * ```typescript
+     * wsClient.disconnect();
+     * ```
+     */
+    disconnect(): void;
+    /**
+     * Subscribes to a channel.
+     *
+     * @param channel - Channel to subscribe to
+     * @param options - Subscription options
+     * @returns Promise that resolves when subscribed
+     * @throws Error if not connected
+     *
+     * @example
+     * ```typescript
+     * // Subscribe to orderbook for a specific market
+     * await wsClient.subscribe('orderbook', { marketSlug: 'market-123' });
+     *
+     * // Subscribe to all trades
+     * await wsClient.subscribe('trades');
+     *
+     * // Subscribe to your orders
+     * await wsClient.subscribe('orders');
+     * ```
+     */
+    subscribe(channel: SubscriptionChannel, options?: SubscriptionOptions): Promise<void>;
+    /**
+     * Unsubscribes from a channel.
+     *
+     * @param channel - Channel to unsubscribe from
+     * @param options - Subscription options (must match subscribe call)
+     * @returns Promise that resolves when unsubscribed
+     *
+     * @example
+     * ```typescript
+     * await wsClient.unsubscribe('orderbook', { marketSlug: 'market-123' });
+     * ```
+     */
+    unsubscribe(channel: SubscriptionChannel, options?: SubscriptionOptions): Promise<void>;
+    /**
+     * Registers an event listener.
+     *
+     * @param event - Event name
+     * @param handler - Event handler
+     * @returns This client for chaining
+     *
+     * @example
+     * ```typescript
+     * wsClient
+     *   .on('orderbook', (data) => console.log('Orderbook:', data))
+     *   .on('trade', (data) => console.log('Trade:', data))
+     *   .on('error', (error) => console.error('Error:', error));
+     * ```
+     */
+    on<K extends keyof WebSocketEvents>(event: K, handler: WebSocketEvents[K]): this;
+    /**
+     * Registers a one-time event listener.
+     *
+     * @param event - Event name
+     * @param handler - Event handler
+     * @returns This client for chaining
+     */
+    once<K extends keyof WebSocketEvents>(event: K, handler: WebSocketEvents[K]): this;
+    /**
+     * Removes an event listener.
+     *
+     * @param event - Event name
+     * @param handler - Event handler to remove
+     * @returns This client for chaining
+     */
+    off<K extends keyof WebSocketEvents>(event: K, handler: WebSocketEvents[K]): this;
+    /**
+     * Attach any pending event listeners that were added before connect().
+     * @internal
+     */
+    private attachPendingListeners;
+    /**
+     * Setup internal event handlers for connection management.
+     * @internal
+     */
+    private setupEventHandlers;
+    /**
+     * Re-subscribes to all previous subscriptions after reconnection.
+     * @internal
+     */
+    private resubscribeAll;
+    /**
+     * Creates a unique subscription key.
+     * @internal
+     */
+    private getSubscriptionKey;
+    /**
+     * Extracts channel from subscription key.
+     * @internal
+     */
+    private getChannelFromKey;
+}
+
+export { type AMMPosition, APIError, type ActiveMarketsParams, type ActiveMarketsResponse, type ActiveMarketsSortBy, type AuthResult, AuthenticatedClient, type AuthenticatedClientConfig, Authenticator, BASE_SEPOLIA_CHAIN_ID, type BaseOrderArgs, type CLOBPosition, CONTRACT_ADDRESSES, type ClientType, ConsoleLogger, type CreatedOrder, DEFAULT_API_URL, DEFAULT_CHAIN_ID, DEFAULT_WS_URL, type FOKOrderArgs, type FillEvent, type GTCOrderArgs, HttpClient, type HttpClientConfig, type ILogger, type LatestTrade, type LoginOptions, type Market, MarketFetcher, type MarketOutcome, type MarketPrice, MarketType, type MarketUpdate, type MarketsResponse, MessageSigner, type ModeInfo, type NewOrderPayload, NoOpLogger, type OrderArgs, type OrderBook, OrderBuilder, OrderClient, type OrderClientConfig, type OrderMatch, type OrderResponse, OrderSigner, type OrderSigningConfig, OrderType, type OrderUpdate, type OrderbookEntry, type OrderbookUpdate, PortfolioFetcher, type PortfolioPositionsResponse, type PortfolioSummary, type Position, type PositionMarket, type PositionSide, type PriceUpdate, RetryConfig, type RetryConfigOptions, RetryableClient, SIGNING_MESSAGE_TEMPLATE, Side, type SignatureHeaders, SignatureType, type SignedOrder, type SubscriptionChannel, type SubscriptionOptions, type TokenBalance, type TradeEvent, type TradingMode, type UnsignedOrder, type UserData, type UserProfile, ValidationError, WebSocketClient, type WebSocketConfig, type WebSocketEvents, WebSocketState, ZERO_ADDRESS, getContractAddress, retryOnErrors, validateOrderArgs, validateSignedOrder, validateUnsignedOrder, withRetry };