@agg-build/sdk 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,2546 @@
+/** Use these constants instead of hardcoding "kalshi" or "polymarket". */
+declare enum Venue {
+    kalshi = "kalshi",
+    polymarket = "polymarket",
+    limitless = "limitless",
+    opinion = "opinion",
+    predict = "predict",
+    probable = "probable",
+    myriad = "myriad",
+    hyperliquid = "hyperliquid"
+}
+/** Single source of truth for venue identifiers. */
+declare const VENUES: readonly [Venue.kalshi, Venue.polymarket, Venue.limitless, Venue.opinion, Venue.predict, Venue.probable, Venue.myriad, Venue.hyperliquid];
+
+declare enum ImageSize {
+    sm = 44,
+    md = 48,
+    lg = 60,
+    original = 0
+}
+declare const IMAGE_SIZES: readonly [ImageSize.sm, ImageSize.md, ImageSize.lg];
+
+declare enum AccountType {
+    oauth = "oauth",
+    siwe = "siwe",
+    siws = "siws",
+    email = "email"
+}
+declare enum AccountProvider {
+    wallet = "wallet",
+    solana_wallet = "solana_wallet",
+    google = "google",
+    twitter = "twitter",
+    apple = "apple",
+    email = "email"
+}
+
+declare enum Chain {
+    evm = "evm",
+    svm = "svm"
+}
+
+declare enum MatchStatus {
+    pending = "pending",
+    unmatched = "unmatched",
+    review = "review",
+    matched = "matched",
+    verified = "verified",
+    rejected = "rejected"
+}
+declare enum MatchType {
+    manual = "manual",
+    llm = "llm"
+}
+/** Match statuses considered "confirmed" for user-facing data (orderbooks, listings, aggregation). */
+declare const CONFIRMED_MATCH_STATUSES: MatchStatus[];
+declare enum MarketStatus {
+    open = "open",
+    closed = "closed",
+    resolved = "resolved",
+    unopened = "unopened",
+    paused = "paused"
+}
+
+declare enum OrderStatus {
+    pending = "pending",
+    signing = "signing",
+    pending_bridge = "pending_bridge",
+    submitting = "submitting",
+    submitted = "submitted",
+    filled = "filled",
+    partial_fill = "partial_fill"
+}
+declare enum TradeSide$1 {
+    Buy = "buy",
+    Sell = "sell"
+}
+
+/**
+ * Standalone type definitions — no Zod dependency.
+ * These mirror the types in types/index.ts but are defined as plain interfaces.
+ * Used by the types-only barrel to avoid leaking Zod into SDK/hooks declarations.
+ */
+
+type HelloResponse = {
+    message: string;
+};
+type App = {
+    id: string;
+    name: string;
+    allowedOrigins: string[];
+    active: boolean;
+    blockedCountries: string[];
+    blockedRegions: string[];
+    orderFee: string;
+    signupBonus: string;
+    createdAt: string;
+    updatedAt: string;
+};
+type CreateApp = {
+    name: string;
+    allowedOrigins: string[];
+    blockedCountries: string[];
+    blockedRegions: string[];
+};
+type NonceResponse = {
+    nonce: string;
+};
+type AuthUser = {
+    id: string;
+};
+type UserProfile = {
+    id: string;
+    username: string | null;
+    avatarUrl: string | null;
+    externalId: string | null;
+    isLocationBlocked: boolean;
+    accounts: {
+        type: AccountType;
+        provider: AccountProvider;
+        providerAccountId: string;
+    }[];
+    wallets: {
+        chain: Chain;
+        address: string;
+    }[];
+    venueAccounts: {
+        status: string;
+        id: string;
+        venue: Venue;
+        kycStatus: string;
+    }[] | null;
+};
+type Account = {
+    type: AccountType;
+    provider: AccountProvider;
+    providerAccountId: string;
+};
+type ServerWallet = {
+    chain: Chain;
+    address: string;
+};
+type UpdateUserBody = {
+    username?: string | undefined;
+    confirmAvatar?: true | undefined;
+    removeAvatar?: true | undefined;
+};
+type VerifyBody = {
+    message: string;
+    signature: string;
+};
+type VerifyResponse = {
+    accessToken: string;
+    user: {
+        id: string;
+    };
+    refreshToken?: string | undefined;
+};
+type AuthTokenResponse = {
+    accessToken: string;
+    user: {
+        id: string;
+    };
+    refreshToken?: string | undefined;
+};
+type AuthCodeResponse = {
+    code: string;
+};
+type UpsertVenueKey = {
+    venue: Venue.kalshi;
+    credentials: {
+        keyId: string;
+        privateKey: string;
+    };
+} | {
+    venue: Venue.polymarket;
+    credentials: {
+        apiKey: string;
+        secret: string;
+        passphrase: string;
+    };
+};
+type VenueKeySummary = {
+    updatedAt: string;
+    venue: Venue;
+};
+type TradeSplit = {
+    venue: Venue;
+    venueMarketOutcomeId: string;
+    side: TradeSide$1;
+    price: number;
+    size: number;
+    signedOrder?: any;
+    negRisk?: boolean | undefined;
+    outcomeExternalIdentifier?: string | undefined;
+};
+type ComputeSplitsSelection = {
+    venue: Venue;
+    venueMarketOutcomeId: string;
+};
+type SetupVenueKeyStep = {
+    type: "setup_venue_key";
+    venue: Venue;
+    stepPayload: {
+        instructions: string;
+        setupUrl?: string | undefined;
+    };
+};
+type DepositStep = {
+    type: "deposit";
+    venue: Venue;
+    currency: string;
+    stepPayload?: {
+        instructions: string;
+        setupUrl?: string | undefined;
+        depositUrl?: string | undefined;
+    } | undefined;
+    requiredAmountCents?: number | undefined;
+    requiredAmountUsd?: string | undefined;
+    transactionData?: {
+        value: string;
+        chainId: number;
+        to: string;
+        data: string;
+    } | undefined;
+};
+type SetupDepositAddressStep = {
+    type: "setup_deposit_address";
+    venue: Venue.polymarket;
+    stepPayload: {
+        setupUrl: string;
+        instructions: string;
+    };
+};
+type ValidateBalanceOnClientStep = {
+    type: "validate_balance_on_client";
+    venue: Venue.polymarket;
+    stepPayload: {
+        requiredAmountUsd: string;
+        instructions?: string | undefined;
+        currency?: string | undefined;
+    };
+};
+type TradeStep = {
+    type: "setup_venue_key";
+    venue: Venue;
+    stepPayload: {
+        instructions: string;
+        setupUrl?: string | undefined;
+    };
+} | {
+    type: "deposit";
+    venue: Venue;
+    currency: string;
+    stepPayload?: {
+        instructions: string;
+        setupUrl?: string | undefined;
+        depositUrl?: string | undefined;
+    } | undefined;
+    requiredAmountCents?: number | undefined;
+    requiredAmountUsd?: string | undefined;
+    transactionData?: {
+        value: string;
+        chainId: number;
+        to: string;
+        data: string;
+    } | undefined;
+} | {
+    type: "setup_deposit_address";
+    venue: Venue.polymarket;
+    stepPayload: {
+        setupUrl: string;
+        instructions: string;
+    };
+} | {
+    type: "validate_balance_on_client";
+    venue: Venue.polymarket;
+    stepPayload: {
+        requiredAmountUsd: string;
+        instructions?: string | undefined;
+        currency?: string | undefined;
+    };
+};
+type ValidateTradeRequest = {
+    splits: {
+        venue: Venue;
+        venueMarketOutcomeId: string;
+        side: TradeSide$1;
+        price: number;
+        size: number;
+        signedOrder?: any;
+        negRisk?: boolean | undefined;
+        outcomeExternalIdentifier?: string | undefined;
+    }[];
+};
+type ValidateTradeResponse = {
+    steps: ({
+        type: "setup_venue_key";
+        venue: Venue;
+        stepPayload: {
+            instructions: string;
+            setupUrl?: string | undefined;
+        };
+    } | {
+        type: "deposit";
+        venue: Venue;
+        currency: string;
+        stepPayload?: {
+            instructions: string;
+            setupUrl?: string | undefined;
+            depositUrl?: string | undefined;
+        } | undefined;
+        requiredAmountCents?: number | undefined;
+        requiredAmountUsd?: string | undefined;
+        transactionData?: {
+            value: string;
+            chainId: number;
+            to: string;
+            data: string;
+        } | undefined;
+    } | {
+        type: "setup_deposit_address";
+        venue: Venue.polymarket;
+        stepPayload: {
+            setupUrl: string;
+            instructions: string;
+        };
+    } | {
+        type: "validate_balance_on_client";
+        venue: Venue.polymarket;
+        stepPayload: {
+            requiredAmountUsd: string;
+            instructions?: string | undefined;
+            currency?: string | undefined;
+        };
+    })[];
+    canExecute: boolean;
+};
+type ExecuteTradeRequest = {
+    splits: {
+        venue: Venue;
+        venueMarketOutcomeId: string;
+        side: TradeSide$1;
+        price: number;
+        size: number;
+        signedOrder?: any;
+        negRisk?: boolean | undefined;
+        outcomeExternalIdentifier?: string | undefined;
+    }[];
+};
+type ExecuteTradeResponse = {
+    orders: {
+        venue: Venue;
+        orders: {
+            orderId: string;
+        }[];
+    }[];
+    errors?: {
+        message: string;
+        venue: Venue;
+    }[] | undefined;
+};
+type GetBalanceQuery = {
+    venue: Venue;
+};
+type GetBalanceResponse = {
+    venue: Venue;
+    currency: string;
+    balances: {
+        tradingBalanceCents?: number | undefined;
+        walletBalanceCents?: number | undefined;
+    };
+};
+type WalletChainBalance = {
+    chainId: number;
+    tokenAddress: string;
+    balanceRaw: string;
+    lastSyncedAt: string;
+};
+type WalletTokenBalance = {
+    tokenSymbol: string;
+    totalRaw: string;
+    decimals: number;
+    chains: {
+        chainId: number;
+        tokenAddress: string;
+        balanceRaw: string;
+        decimals: number;
+        lastSyncedAt: string;
+    }[];
+};
+type VenuePositionBalance = {
+    venue: Venue;
+    balance: number;
+    costBasis: number;
+    unrealizedPnl: number;
+    realizedPnl: number;
+};
+type UnifiedBalanceResponse = {
+    cash: {
+        tokenSymbol: string;
+        totalRaw: string;
+        decimals: number;
+        chains: {
+            chainId: number;
+            tokenAddress: string;
+            balanceRaw: string;
+            decimals: number;
+            lastSyncedAt: string;
+        }[];
+    }[];
+    positions: {
+        venue: Venue;
+        balance: number;
+        costBasis: number;
+        unrealizedPnl: number;
+        realizedPnl: number;
+    }[];
+};
+type UserHolding = {
+    venue: Venue;
+    side: "long" | "short";
+    size: number;
+    marketId: string;
+    outcomeId: string;
+    outcomeLabel?: string | undefined;
+    conditionId?: string | undefined;
+    avgPrice?: number | undefined;
+    pnl?: number | undefined;
+};
+type GetHoldingsResponse = {
+    data: {
+        venue: Venue;
+        side: "long" | "short";
+        size: number;
+        marketId: string;
+        outcomeId: string;
+        outcomeLabel?: string | undefined;
+        conditionId?: string | undefined;
+        avgPrice?: number | undefined;
+        pnl?: number | undefined;
+    }[];
+    nextCursor: string | null;
+    hasMore: boolean;
+};
+type GetHoldingsQuery = {
+    venue: Venue;
+    venueMarketId?: string | undefined;
+    venueEventId?: string | undefined;
+    cursor?: string | undefined;
+};
+type GetOrdersQuery = {
+    status?: OrderStatus | undefined;
+    orderId?: string | undefined;
+    cursor?: string | undefined;
+    limit?: number | undefined;
+};
+type GetPositionsQuery = {
+    cursor?: string | undefined;
+    limit?: number | undefined;
+    status?: "active" | "closed" | undefined;
+};
+type OrderListItem = {
+    status: string;
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    venue: Venue;
+    side: string;
+    amountRaw: string;
+    slippageBps: number | null;
+    quotedPriceRaw: string | null;
+    quotedCostRaw: string | null;
+    filledAmountRaw: string | null;
+    executionPrice: string | null;
+    txHash: string | null;
+    errorMessage: string | null;
+    dagRunId: string | null;
+    venueMarket: {
+        id: string;
+        venueEventId?: string | undefined;
+        question: string;
+        image: string | null;
+    } | null;
+    venueMarketOutcome: {
+        label: string;
+        title: string | null;
+    } | null;
+};
+type PositionGroup = {
+    venueMarket: {
+        venueEventId: string;
+        question: string;
+        image: string | null;
+        status: MarketStatus;
+        venueMarketOutcomes: {
+            unrealizedPnl: number;
+            label: string;
+            title: string | null;
+            winner: boolean | null;
+            venueBreakdown: {
+                venue: Venue;
+                size: number;
+                venueMarketId: string;
+                venueMarketOutcomeId?: string | null;
+            }[];
+            totalSize: number;
+            avgEntryPrice: number;
+            currentPrice: number;
+            totalValue: number;
+            unrealizedPnlPercent: number;
+        }[];
+    };
+    targetMarketId: string;
+    eventId?: string | undefined;
+    redeemStatus: "eligible" | "pending" | "redeemed" | "ineligible";
+    status: "active" | "closed";
+    resolutionDate: string | null;
+};
+type VenueMarket = {
+    id: string;
+    venue: Venue;
+    question: string;
+    venueMarketOutcomes: {
+        id: string;
+        price: number;
+        venueMarketId: string;
+        label: string;
+        title?: string | null | undefined;
+        externalIdentifier?: string | null | undefined;
+        winner?: boolean | null | undefined;
+    }[];
+    externalIdentifier: string;
+    status?: MarketStatus | undefined;
+    createdAt?: string | null | undefined;
+    negRisk?: boolean | undefined;
+    marketId?: string | null | undefined;
+    conditionId?: string | null | undefined;
+    venueEventId?: string | null | undefined;
+    image?: string | null | undefined;
+    description?: string | null | undefined;
+    rulesPrimary?: string | null | undefined;
+    rulesSecondary?: string | null | undefined;
+    volume?: number | null | undefined;
+    startDate?: string | null | undefined;
+    endDate?: string | null | undefined;
+    creationDate?: string | null | undefined;
+    resolutionDate?: string | null | undefined;
+    matchedVenueMarkets?: {
+        id: string;
+        venue: Venue;
+        question: string;
+        externalIdentifier: string;
+        status?: MarketStatus | undefined;
+        conditionId?: string | null | undefined;
+        venueMarketOutcomes?: {
+            id: string;
+            price: number;
+            venueMarketId: string;
+            label: string;
+            winner?: boolean | null | undefined;
+        }[] | undefined;
+        volume?: number | null | undefined;
+        venueEvent?: {
+            id: string;
+            externalIdentifier: string;
+            slug?: string | null | undefined;
+            series?: {
+                id: string;
+                venue: string;
+                externalIdentifier: string;
+                name?: string | null | undefined;
+            } | null | undefined;
+        } | null | undefined;
+    }[] | undefined;
+};
+type VenueEvent = {
+    id: string;
+    venue: Venue;
+    image: string | null;
+    title: string;
+    externalIdentifier: string;
+    categories: {
+        id: string;
+        category: {
+            id: string;
+            name: string;
+            parentId: string | null;
+            eventCount: number;
+        };
+    }[];
+    status?: MarketStatus | undefined;
+    updatedAt?: string | null | undefined;
+    description?: string | null | undefined;
+    volume?: number | null | undefined;
+    startDate?: string | null | undefined;
+    endDate?: string | null | undefined;
+    creationDate?: string | null | undefined;
+    slug?: string | null | undefined;
+    subtitle?: string | null | undefined;
+    venues?: Venue[];
+    venueCount?: number | undefined;
+    marketCount?: number | undefined;
+};
+type Orderbook = {
+    bids: {
+        price: number;
+        size: number;
+    }[];
+    asks: {
+        price: number;
+        size: number;
+    }[];
+    negRisk?: boolean | undefined;
+};
+type AttributedOrderbookLevel = {
+    price: number;
+    size: number;
+    venues: Record<string, number>;
+};
+type AttributedOrderbook = {
+    bids: {
+        price: number;
+        size: number;
+        venues: Record<string, number>;
+    }[];
+    asks: {
+        price: number;
+        size: number;
+        venues: Record<string, number>;
+    }[];
+};
+type PricePoint = {
+    price: number;
+    timestamp: number;
+    open?: number | undefined;
+    high?: number | undefined;
+    low?: number | undefined;
+    close?: number | undefined;
+};
+type MarketPriceHistory = {
+    venue: Venue;
+    marketId: string;
+    marketTicker: string;
+    points: {
+        price: number;
+        timestamp: number;
+        open?: number | undefined;
+        high?: number | undefined;
+        low?: number | undefined;
+        close?: number | undefined;
+    }[];
+};
+type PricesHistoryResponse = {
+    data: {
+        venue: Venue;
+        marketId: string;
+        marketTicker: string;
+        points: {
+            price: number;
+            timestamp: number;
+            open?: number | undefined;
+            high?: number | undefined;
+            low?: number | undefined;
+            close?: number | undefined;
+        }[];
+    }[];
+};
+type OrderbookHistoryPoint = {
+    volume: number | null;
+    timestamp: number;
+    midpoint: number;
+    bestBid: number | null;
+    bestAsk: number | null;
+    spread: number | null;
+    open?: number | undefined;
+    high?: number | undefined;
+    low?: number | undefined;
+    close?: number | undefined;
+};
+type OrderbookHistoryResponse = {
+    venueMarketOutcomeId: string;
+    points: {
+        volume: number | null;
+        timestamp: number;
+        midpoint: number;
+        bestBid: number | null;
+        bestAsk: number | null;
+        spread: number | null;
+        open?: number | undefined;
+        high?: number | undefined;
+        low?: number | undefined;
+        close?: number | undefined;
+    }[];
+};
+type VenueMarketOutcome = {
+    id: string;
+    price: number;
+    venueMarketId: string;
+    label: string;
+    title?: string | null | undefined;
+    externalIdentifier?: string | null | undefined;
+    winner?: boolean | null | undefined;
+};
+type VenueEventWithMarkets = VenueEvent & {
+    venueMarkets: VenueMarket[];
+};
+type VenueMarketListItem = Omit<VenueMarket, "matchedVenueMarkets">;
+type VenueEventListItem = VenueEvent & {
+    venueMarkets: VenueMarketListItem[];
+    marketCount: number;
+};
+type MatchedMidpoint = {
+    venueMarketId: string;
+    venue: string;
+    midpoint: number | null;
+};
+type OutcomeMidpoint = {
+    venueMarketOutcomeId: string;
+    label: string;
+    midpoint: number | null;
+};
+type MidpointItem = {
+    venueMarketId: string;
+    venue: string;
+    midpoint: number | null;
+    spread: number | null;
+    timestamp: number | null;
+    outcomes: OutcomeMidpoint[];
+    matched: MatchedMidpoint[];
+};
+type ComputeSplitsRequest = {
+    side: TradeSide$1;
+    selections: {
+        venue: Venue;
+        venueMarketOutcomeId: string;
+    }[];
+    maxDollarAmount: number;
+};
+type ComputeSplitsResponse = {
+    splits: {
+        venue: Venue;
+        venueMarketOutcomeId: string;
+        side: TradeSide$1;
+        price: number;
+        size: number;
+        signedOrder?: any;
+        negRisk?: boolean | undefined;
+        outcomeExternalIdentifier?: string | undefined;
+    }[];
+    totalSize: number;
+    totalCost: number;
+};
+type Category = {
+    id: string;
+    name: string;
+    parentId: string | null;
+    eventCount: number;
+};
+type SettlementSource = {
+    name: string;
+    url?: string | null | undefined;
+};
+type QuoteManagedRequest = {
+    venueMarketOutcomeIds: string[];
+    side: "buy" | "sell";
+    amount: number;
+    slippageBps?: number | undefined;
+};
+type QuoteStep = {
+    type: string;
+    description: string;
+    estimatedDurationMs: number;
+};
+type QuoteSplit = {
+    venue: Venue;
+    venueMarketId: string;
+    venueMarketOutcomeId: string;
+    tokenId: string;
+    price: string;
+    size: string;
+    costRaw: string;
+};
+type ExecuteManagedRequest = {
+    quoteId: string;
+};
+type ValidateManagedRequest = {
+    venueMarketOutcomeIds: string[];
+    side: "buy" | "sell";
+    amount: number;
+};
+type WithdrawManagedRequest = {
+    amountRaw: string;
+    tokenSymbol: string;
+    destinationAddress: string;
+    destinationChainId?: number | undefined;
+};
+type WithdrawalSource = {
+    amountRaw: string;
+    chainId: number;
+    txHash?: string | undefined;
+    bridgeOperationId?: string | undefined;
+};
+type SyncBalancesResponse = {
+    synced: true;
+};
+type MatchingReport = {
+    summary: {
+        events: {
+            pending: number;
+            total: number;
+            unmatched: number;
+            review: number;
+            matched: number;
+            verified: number;
+            rejected: number;
+        };
+        markets: {
+            pending: number;
+            total: number;
+            unmatched: number;
+            review: number;
+            matched: number;
+            verified: number;
+            rejected: number;
+        };
+        crossVenue: {
+            events: number;
+            markets: number;
+        };
+        matchTypes: {
+            manual: number;
+            llm: number;
+            dome: number;
+        };
+        llm: {
+            pending: number;
+            total: number;
+            matched: number;
+            rejected: number;
+            resolved: number;
+            failed: number;
+            avgConfidenceMatched: number | null;
+            avgConfidenceRelated: number | null;
+            avgConfidenceNoMatch: number | null;
+            avgLatencyMs: number | null;
+        };
+    };
+    matchDistribution: {
+        events: {
+            min: number;
+            max: number;
+            avg: number;
+        };
+        markets: {
+            min: number;
+            max: number;
+            avg: number;
+        };
+    };
+    byCategory: {
+        total: number;
+        unmatched: number;
+        matched: number;
+        categoryId: string;
+        categoryName: string;
+        byVenue: Record<string, number>;
+    }[];
+    byVenue: {
+        venue: string;
+        events: {
+            total: number;
+            matched: number;
+            verified: number;
+            rejected: number;
+        };
+        markets: {
+            total: number;
+            matched: number;
+            verified: number;
+            rejected: number;
+        };
+    }[];
+    timeSeries: {
+        date: string;
+        matchedEvents: number;
+        matchedMarkets: number;
+        llmTotal: number;
+        llmMatched: number;
+        llmRejected: number;
+    }[];
+};
+
+/**
+ * API response-boundary formatters for market display fields.
+ *
+ * Called by the response mappers (mapVenueMarketRow, toVenueEventDto) to
+ * produce display-ready text before it reaches the client. Internal code
+ * (matching, sorting, DB) uses the raw DB values.
+ */
+/**
+ * Resolve the display label for a VenueMarketOutcome.
+ *
+ * - **Kalshi:** Always return `label`. Kalshi's label IS the canonical
+ *   display text ("Yes"/"No"); `title` is a subtitle shown elsewhere.
+ * - **All other venues:** Return `title` if present and non-empty,
+ *   otherwise `label`. Polymarket normalizes binary outcomes to
+ *   "Yes"/"No" labels and stores the original descriptive text in `title`
+ *   (e.g. label="Yes", title="Trump Wins").
+ *
+ * When `market` context is provided and the outcome's `title` duplicates
+ * the market's `question` (a known Limitless group-sub-market quirk where
+ * the driver name lands on every outcome's title), fall back to `label`
+ * so "Yes"/"No" remain distinguishable instead of both collapsing to the
+ * market subject.
+ */
+declare function formatOutcomeLabel(venue: Venue, outcome: {
+    label: string;
+    title?: string | null;
+}, _market?: {
+    question?: string | null;
+}): string;
+/**
+ * Resolve the display question for a VenueMarket.
+ *
+ * - **Kalshi:** Return the first outcome's `title` if available. Kalshi
+ *   market tickers (e.g. "INXD-26APR08-T7563.43") are stored in
+ *   `question` but the human-readable text is in the outcome's `title`
+ *   (e.g. "S&P 500 closes above 7,563.43"). Falls back to `question` if
+ *   no outcome title exists.
+ * - **All other venues:** Return `question` as-is (already human-readable).
+ */
+declare function formatMarketQuestion(venue: Venue, market: {
+    question: string;
+    shortTitle?: string | null;
+    venueMarketOutcomes?: Array<{
+        label: string;
+        title?: string | null;
+    }>;
+}): string;
+
+declare function getWalletAddressFromUserProfile(user: UserProfile | undefined): string | undefined;
+
+/**
+ * Lightweight runtime validation utilities — zero dependencies.
+ * Replaces Zod's safeParse/parse for simple type-guard-based validation.
+ */
+type SafeParseSuccess<T> = {
+    success: true;
+    data: T;
+};
+type SafeParseFailure = {
+    success: false;
+    error?: {
+        issues: Array<{
+            message: string;
+        }>;
+    };
+};
+type SafeParseResult<T> = SafeParseSuccess<T> | SafeParseFailure;
+/** Generic safeParse — drop-in replacement for zod's schema.safeParse(). */
+declare function safeParse<T>(value: unknown, guard: (v: unknown) => v is T): SafeParseResult<T>;
+/** Throwing parse — drop-in replacement for zod's schema.parse(). */
+declare function parse<T>(value: unknown, guard: (v: unknown) => v is T, message?: string): T;
+/** Creates a type guard for a set of string values (enums, string unions). */
+declare function isEnum<T extends string>(values: ReadonlySet<string>): (v: unknown) => v is T;
+/** Creates a type guard for a set of string values from an enum or array. */
+declare function enumGuard<T extends string>(source: Record<string, T> | readonly T[]): (v: unknown) => v is T;
+/** Finite, non-negative number. */
+declare function isFiniteNonNeg(v: unknown): v is number;
+/** Non-empty string. */
+declare function isNonEmptyString(v: unknown): v is string;
+/** Object with specific keys present and of the right primitive type. */
+declare function hasShape<T>(v: unknown, checks: Record<string, (val: unknown) => boolean>): v is T;
+/**
+ * Linear-scan email check matching /^[^\s@]+@[^\s@]+\.[^\s@]+$/ semantics
+ * without polynomial-regex backtracking. Exported so the API's TypeBox
+ * FormatRegistry can share the same implementation.
+ */
+declare function isEmail(v: string): boolean;
+/** Validates + trims email. Returns safeParse-compatible result with error.issues shape. */
+declare function parseEmail(raw: string): SafeParseResult<{
+    email: string;
+}>;
+/** Strict email parse — throws with .issues for catch-block compat. */
+declare function parseEmailStrict(raw: string): {
+    email: string;
+};
+
+interface SplitsByAmountResult {
+    splits: TradeSplit[];
+    totalSize: number;
+    totalCost: number;
+}
+declare function computeBestSplitsByAmount$1(selections: Array<{
+    market: VenueMarket;
+    outcome: VenueMarketOutcome;
+    orderbook: Orderbook;
+}>, side: TradeSide$1, maxDollarAmount: number): SplitsByAmountResult;
+
+/**
+ * Rewrite a CDN image URL to use the pre-processed variant closest to `maxPx`.
+ *
+ * - CDN URLs ending in `/original.webp` or `/{size}.webp` are rewritten.
+ * - External URLs (venue logos, non-CDN) pass through unchanged.
+ * - Falsy inputs return `undefined`.
+ *
+ * @param url  Full image URL from the API (e.g. `https://assets.agg.market/users/.../original.webp`)
+ * @param maxPx  Largest dimension the image will be rendered at, in CSS pixels.
+ *               Pass the **largest** responsive breakpoint size (e.g. 60 for `size-10 md:size-[60px]`).
+ */
+declare function optimizedImageUrl(url: string | null | undefined, maxPx: number): string | undefined;
+
+type VenueMarketClusterNode<TMarket = unknown> = {
+    id: string;
+    venue: string;
+    matchedVenueMarkets?: readonly TMarket[] | null;
+    matchEntry?: {
+        targetVenueMarketId?: string | null;
+        targetVenueMarket?: TMarket | null;
+    } | null | undefined;
+    venues?: readonly string[] | null;
+    venueCount?: number | null;
+};
+declare const normalizeVenueMarketCluster: <TMarket extends VenueMarketClusterNode<TMarket>>(markets: readonly TMarket[], selectedMarketId?: string | null) => TMarket[];
+
+declare const sortVenues: <T extends string>(venues: readonly T[]) => T[];
+
+/**
+ * WebSocket protocol types for the Agg platform.
+ * All callback timestamps are in **seconds** (converted from server ms at SDK dispatch).
+ * These are plain TS interfaces — no Zod dependency for partner-side usage.
+ */
+/** Aggregated level wire format: [price, totalSize, {venue: sizeAtPrice}] */
+type WsAttributedLevel = [number, number, Record<string, number>];
+/** Per-venue level wire format: [price, size] */
+type WsVenueLevel = [number, number];
+interface WsVenueInfo {
+    bestBid: number | null;
+    bestAsk: number | null;
+}
+interface WsVenueBook {
+    bids: WsVenueLevel[];
+    asks: WsVenueLevel[];
+}
+interface WsOrderbookSnapshot {
+    type: "orderbook_snapshot";
+    outcomeId: string;
+    channel?: "orderbook" | "trades";
+    seq: number;
+    checksum: number;
+    bids: WsAttributedLevel[];
+    asks: WsAttributedLevel[];
+    venueOrderbooks: Record<string, WsVenueBook>;
+    venues: Record<string, WsVenueInfo>;
+    midpoint: number | null;
+    spread: number | null;
+    /** @unit seconds (converted from server ms) */
+    timestamp: number;
+    /**
+     * Sticky tick of this outcome's book, inferred at runtime by the engine.
+     * `null` until inferred. Optional — older snapshot producers (REST fallback)
+     * may omit this field entirely.
+     */
+    tick?: number | null;
+    /** Provenance of the published `midpoint`. See {@link MarkSource}. */
+    markSource?: MarkSource$1;
+}
+/**
+ * Provenance tag for a published midpoint. Mirrors the Rust engine
+ * `MarkSource::as_str()` output.
+ */
+type WsMarkSource = "local" | "local_merged" | "local_one_sided" | "sibling" | "local_boundary" | "none";
+type MarkSource$1 = WsMarkSource;
+interface WsOrderbookDelta {
+    type: "orderbook_delta";
+    outcomeId: string;
+    channel?: "orderbook" | "trades";
+    seq: number;
+    checksum: number;
+    bidChanges: WsAttributedLevel[];
+    askChanges: WsAttributedLevel[];
+    venueDeltaBooks: Record<string, {
+        bidChanges: WsVenueLevel[];
+        askChanges: WsVenueLevel[];
+    }>;
+    venues: Record<string, WsVenueInfo>;
+    midpoint: number | null;
+    spread: number | null;
+    /** @unit seconds (converted from server ms) */
+    timestamp: number;
+}
+interface WsTrade {
+    type: "trade";
+    outcomeId: string;
+    channel?: "orderbook" | "trades";
+    venue: string;
+    side: "buy" | "sell";
+    price: number;
+    size: number;
+    /** @unit seconds (converted from server ms) */
+    timestamp: number;
+}
+type WsCandleInterval = "1m" | "5m" | "1h" | "1d";
+interface WsSubscribed {
+    type: "subscribed";
+    outcomeIds: string[];
+    channel: "orderbook" | "trades";
+}
+interface WsUnsubscribed {
+    type: "unsubscribed";
+    outcomeIds: string[];
+    channel: "orderbook" | "trades";
+}
+interface WsConnected {
+    type: "connected";
+    appId: string;
+    userId?: string;
+}
+interface WsAuthenticated {
+    type: "authenticated";
+    userId: string;
+}
+interface WsHeartbeat {
+    type: "heartbeat";
+    /** @unit seconds (converted from server ms) */
+    ts: number;
+}
+interface WsResolvedOutcome {
+    label: string;
+    winner?: boolean;
+    externalIdentifier?: string;
+}
+interface WsMarketResolved {
+    type: "market_resolved";
+    outcomeId: string;
+    status: "resolved" | "closed";
+    /** Winning outcome label, or null if unknown. */
+    result: string | null;
+    /** Per-outcome resolution data. */
+    outcomes: WsResolvedOutcome[];
+    /** @unit seconds (converted from server ms) */
+    timestamp: number;
+}
+interface WsError {
+    type: "error";
+    message: string;
+}
+interface WsOrderSubmitted {
+    type: "order_submitted";
+    venue: string;
+    orderId: string;
+    side: string;
+    price: number;
+    size: number;
+    outcomeId?: string;
+    /** @unit seconds (converted from server ms) */
+    timestamp: number;
+}
+interface WsBalanceUpdate {
+    type: "balance_update";
+    venue: string;
+    tradingBalanceCents: number;
+    walletBalanceCents?: number;
+    /** @unit seconds (converted from server ms) */
+    timestamp: number;
+}
+type WsOrderEventType = "created" | "signed" | "pending_bridge" | "bridge_complete" | "submitting" | "submitted" | "expired" | "dag_started" | "dag_completed" | "dag_failed" | "dag_cancelled" | "step_started" | "step_completed" | "step_waiting" | "step_failed" | "step_retrying" | "filled" | "partial_fill" | "failed" | "bridge_ws_subscribed" | "bridge_ws_subscribe_failed" | "bridge_polling_fallback";
+interface WsOrderEvent {
+    type: "order_event";
+    event: WsOrderEventType;
+    userId: string;
+    orderId: string;
+    venue: string;
+    dagRunId?: string;
+    stepId?: string;
+    stepType?: string;
+    /** 1-based step index. Pair with `totalSteps` to render "Step 3 of 7". */
+    sequence?: number;
+    totalSteps?: number;
+    templateName?: string;
+    /** Maps sequence → stepType for all steps — sent on dag_started so labels are available upfront. */
+    stepTypes?: Record<number, string>;
+    filledAmountRaw?: string;
+    remainingAmountRaw?: string;
+    errorReason?: string;
+    attempt?: number;
+    correlationId?: string;
+    /** @unit milliseconds (raw from server — NOT converted like other WS types) */
+    timestamp: number;
+}
+interface WsRedeemEvent {
+    type: "redeem_event";
+    redeemId: string;
+    venueMarketOutcomeId: string;
+    status: "submitted" | "confirmed" | "failed";
+    callsId: string | null;
+    pendingUserOpId: string | null;
+    txHash: string | null;
+    errorMessage: string | null;
+    /** @unit seconds (converted from server ms) */
+    timestamp: number;
+}
+type WsServerMessage = WsOrderbookSnapshot | WsOrderbookDelta | WsTrade | WsSubscribed | WsUnsubscribed | WsConnected | WsAuthenticated | WsHeartbeat | WsMarketResolved | WsError | WsOrderSubmitted | WsBalanceUpdate | WsOrderEvent | WsRedeemEvent;
+type WsClientMessage = {
+    action: "subscribe";
+    channel: "orderbook" | "trades";
+    outcomeIds: string[];
+} | {
+    action: "unsubscribe";
+    channel: "orderbook" | "trades";
+    outcomeIds: string[];
+} | {
+    action: "resnapshot";
+    channel: "orderbook";
+    outcomeIds: string[];
+} | {
+    action: "authenticate";
+    token: string;
+};
+type DiagnosticEvent = {
+    type: "seq_gap";
+    marketId: string;
+    outcomeId: string;
+    expected: number;
+    received: number;
+} | {
+    type: "checksum_mismatch";
+    marketId: string;
+    outcomeId: string;
+    expected: number;
+    computed: number;
+} | {
+    type: "reconnect";
+    attempt: number;
+    delayMs: number;
+} | {
+    type: "stale_connection";
+    lastMessageAge: number;
+};
+type DiagnosticCallback = (event: DiagnosticEvent) => void;
+
+/**
+ * Immutable orderbook utility functions for the SDK.
+ * Applies WS deltas to local book state, computes checksums for integrity verification.
+ * Every function returns a **new object** — never mutates inputs.
+ */
+
+interface OrderbookLevel {
+    price: number;
+    size: number;
+    venues: Record<string, number>;
+}
+interface VenueOrderbookLevel {
+    price: number;
+    size: number;
+}
+interface OrderbookState {
+    marketId: string;
+    /** The outcome whose price the midpoint represents (e.g. the "Yes" outcome in binary markets). */
+    outcomeId?: string | null;
+    bids: OrderbookLevel[];
+    asks: OrderbookLevel[];
+    venueOrderbooks: Record<string, {
+        bids: VenueOrderbookLevel[];
+        asks: VenueOrderbookLevel[];
+    }>;
+    venues: Record<string, WsVenueInfo>;
+    midpoint: number | null;
+    spread: number | null;
+    seq: number;
+    checksum: number;
+    /** @unit seconds */
+    timestamp: number;
+}
+/**
+ * Compute the XOR-based checksum of an orderbook.
+ * Matches the Rust engine's checksum: XOR of crc32("B{price}:{size}") for each
+ * bid and crc32("A{price}:{size}") for each ask, independently hashed then XOR'd.
+ */
+declare function computeChecksum(book: {
+    bids: OrderbookLevel[];
+    asks: OrderbookLevel[];
+}): number;
+/**
+ * Convert a WS snapshot message into local OrderbookState.
+ * Timestamp is expected to already be in seconds (converted by AggWebSocket).
+ */
+declare function snapshotToOrderbook(snapshot: WsOrderbookSnapshot): OrderbookState;
+/**
+ * Apply a WS delta to an existing OrderbookState, returning a new state.
+ * Bids sorted descending, asks ascending (maintained invariant).
+ */
+declare function applyOrderbookDelta(state: OrderbookState, delta: WsOrderbookDelta): OrderbookState;
+
+/**
+ * Agg platform WebSocket client.
+ *
+ * Single connection, refcounted subscriptions by ID (venueMarketId or
+ * venueMarketOutcomeId). Maintains in-memory orderbook state per subscribed ID.
+ * All timestamps converted from server ms to seconds before invoking callbacks.
+ *
+ * Recovery: seq gap or checksum mismatch → resnapshot request.
+ * Stale delta guard: deltas with seq <= current book seq are silently dropped.
+ * Liveness: no message for 45s → reconnect (server sends heartbeat every 30s).
+ */
+
+interface AggWebSocketCallbacks {
+    onSnapshot?: (marketId: string, book: OrderbookState) => void;
+    onDelta?: (marketId: string, book: OrderbookState) => void;
+    onTrade?: (trade: WsTrade) => void;
+    onHeartbeat?: (hb: WsHeartbeat) => void;
+    onSubscribed?: (msg: WsSubscribed) => void;
+    onUnsubscribed?: (msg: WsUnsubscribed) => void;
+    onConnected?: (msg: WsConnected) => void;
+    onAuthenticated?: (msg: WsAuthenticated) => void;
+    onMarketResolved?: (msg: WsMarketResolved) => void;
+    onError?: (msg: WsError) => void;
+    onOrderSubmitted?: (msg: WsOrderSubmitted) => void;
+    onBalanceUpdate?: (msg: WsBalanceUpdate) => void;
+    onOrderEvent?: (msg: WsOrderEvent) => void;
+    onRedeemEvent?: (msg: WsRedeemEvent) => void;
+    onDiagnostics?: DiagnosticCallback;
+    onConnectionStateChange?: (connected: boolean) => void;
+}
+interface AggWebSocketOptions {
+    /** Full WebSocket URL including query params (appId). Token should NOT be in the URL. */
+    url: string;
+    callbacks?: AggWebSocketCallbacks;
+    /** JWT to send via the authenticate message after connecting (avoids token in URL/logs). */
+    initialToken?: string;
+    /** Enable websocket debug logs. Default: false. */
+    enableLogs?: boolean;
+}
+/**
+ * Agg WebSocket client. Single WS connection with refcounted market subscriptions.
+ */
+declare class AggWebSocket {
+    private ws;
+    private readonly url;
+    private callbacks;
+    private readonly subs;
+    private readonly pendingSubs;
+    private readonly pendingTradeSubs;
+    private readonly pendingResnapshots;
+    private readonly pendingFlushSubs;
+    private readonly pendingFlushUnsubs;
+    private readonly pendingFlushTradeSubs;
+    private readonly pendingFlushTradeUnsubs;
+    private flushScheduled;
+    private readonly books;
+    /** Markets currently resyncing (awaiting snapshot after seq gap / checksum mismatch). */
+    private readonly resyncing;
+    private connecting;
+    private _connected;
+    private reconnectAttempts;
+    private reconnectTimer;
+    private staleTimer;
+    private lastMessageTime;
+    private destroyed;
+    private initialToken?;
+    private readonly enableLogs;
+    constructor(options: AggWebSocketOptions);
+    get connected(): boolean;
+    /** Get the current orderbook state for an outcome (or null if no snapshot received yet). */
+    getBook(outcomeId: string): OrderbookState | null;
+    /** Whether an outcome is currently resyncing (waiting for fresh snapshot). */
+    isResyncing(outcomeId: string): boolean;
+    /**
+     * Subscribe to a feed by outcome ID.
+     * @param outcomeId  The venueMarketOutcomeId to subscribe to.
+     * @param channel    "orderbook" (default) or "trades".
+     * Returns an unsubscribe function (ref-counted).
+     */
+    subscribe(outcomeId: string, channel?: "orderbook" | "trades"): () => void;
+    /**
+     * Subscribe to an outcome's trade feed.
+     * @deprecated Use `subscribe(outcomeId, "trades")` instead.
+     * Returns an unsubscribe function.
+     */
+    subscribeTrades(outcomeId: string): () => void;
+    private _subscribeTrades;
+    /** Send a JWT to authenticate (or re-authenticate) the connection. */
+    authenticate(token: string): void;
+    /** Request a fresh snapshot for one or more subscribed outcomes. */
+    resnapshot(outcomeIdOrIds: string | string[]): void;
+    /** Connect (idempotent). Called automatically on first subscribe. */
+    connect(): void;
+    /** Disconnect and clean up. Reusable — call connect() to reconnect. */
+    disconnect(): void;
+    /** Permanently destroy. Cannot reconnect after this. */
+    destroy(): void;
+    /** Update callbacks (e.g., after React re-render). */
+    setCallbacks(callbacks: AggWebSocketCallbacks): void;
+    private ensureConnected;
+    private doConnect;
+    private scheduleReconnect;
+    private cancelReconnect;
+    private resetStaleTimer;
+    private cancelStaleTimer;
+    private handleMessage;
+    /**
+     * Server confirmed the connection — gateway has validated our appId and is
+     * ready to accept subscriptions. Now flush all pending subs.
+     */
+    private handleConnected;
+    private handleSnapshot;
+    private handleDelta;
+    private handleTrade;
+    private handleHeartbeat;
+    private handleMarketResolved;
+    private handleOrderSubmitted;
+    private handleBalanceUpdate;
+    private handleRedeemEvent;
+    private requestResnapshot;
+    /**
+     * Schedule a microtask that flushes queued subscribe/unsubscribe frames.
+     * Coalesces multiple same-tick sub/unsub calls into at most one frame per
+     * channel+action pair.
+     */
+    private scheduleFlush;
+    private flushPending;
+    private sendSubscribe;
+    private send;
+    private activeOrderbookMarkets;
+    private activeTradeMarkets;
+    private emitDiagnostic;
+    private summarizeTopLevels;
+    private debugOrderbook;
+    private isOrderbookDebugEnabled;
+}
+
+interface AppClientConfigResponse {
+    disabledVenues: Venue[];
+    disabledCategoryPresets: string[];
+    earlyAccessEnabled: boolean;
+}
+type AggAuthProviderType = "siwe" | "siws" | "google" | "twitter" | "apple" | "email";
+type AggAuthDeliveryMode = "body" | "cookie-refresh";
+interface AggClientAuthOptions {
+    getEarlyAccessCode?: () => string | null;
+}
+type AggAuthStartBody = {
+    provider: Exclude<AggAuthProviderType, "email">;
+    redirectUrl?: string;
+    /** Cloudflare Turnstile token — required when a prior authStart returned `challenge_required`. */
+    turnstileToken?: string;
+    earlyAccessCode?: string;
+} | {
+    provider: "email";
+    email: string;
+    redirectUrl?: string;
+    /** Cloudflare Turnstile token — required when a prior authStart returned `challenge_required`. */
+    turnstileToken?: string;
+    earlyAccessCode?: string;
+};
+interface AggAuthVerifyBody {
+    message: string;
+    signature: string;
+    earlyAccessCode?: string;
+}
+type AggAuthStartResult = {
+    type: "nonce";
+    nonce: string;
+} | {
+    type: "redirect";
+    url: string;
+} | {
+    type: "magic_link";
+    success: true;
+} | {
+    type: "challenge_required";
+    siteKey: string;
+};
+/**
+ * Body for `POST /users/me/link-account/start` — authenticated account linking.
+ *
+ * `redirectUrl` is required for every provider: the callback / magic-link verify
+ * hands the partner a `link_confirm_token` by redirecting to `redirectUrl`, and
+ * the partner app completes the flow by calling `/confirm` from that page.
+ */
+type AggLinkAccountBody = {
+    provider: "google" | "twitter" | "apple";
+    redirectUrl: string;
+} | {
+    provider: "email";
+    email: string;
+    redirectUrl: string;
+};
+type AggLinkAccountResult = {
+    type: "redirect";
+    url: string;
+} | {
+    type: "magic_link";
+    success: true;
+};
+/**
+ * Success result of /users/me/link-account/confirm.
+ * - `linked` — new Account row written.
+ * - `already_linked_same` — identity was already attached to the caller's Principal
+ *   (idempotent; safe to retry).
+ *
+ * Collisions with a different Principal surface as HTTP 409 and are thrown by the
+ * SDK's request layer — catch them at the call site, don't expect them here.
+ */
+type AggLinkAccountConfirmResult = {
+    status: "linked" | "already_linked_same";
+    provider: string;
+};
+type AggSessionUser = AuthUser | UserProfile;
+interface AggClientSessionInput {
+    accessToken: string;
+    refreshToken?: string;
+    user?: AggSessionUser;
+}
+/** Non-sensitive auth snapshot persisted to localStorage for UI bootstrapping.
+ *  Tokens are NEVER included — they exist only in process memory. */
+interface PersistedAuthSnapshot {
+    user: {
+        id: string;
+        username: string | null;
+        avatarUrl: string | null;
+        walletAddress?: string | null;
+    } | null;
+    authHint: {
+        wasAuthenticated: boolean;
+    };
+}
+/** Auth lifecycle status for UI state machines. */
+type AuthStatus = "unknown" | "authenticated" | "unauthenticated";
+interface AggClientOptions {
+    baseUrl: string;
+    /** Public App ID — sent as x-app-id header. For client-side partner usage. */
+    appId?: string;
+    /** Secret admin key — sent as x-admin-key header. Server-side only. */
+    adminKey?: string;
+    /**
+     * Partner API key for server-side use. Sent as `x-app-api-key`. NEVER embed
+     * in browser bundles, source maps, or logs. Keys start with `agg_<appId>_`.
+     */
+    apiKey?: string;
+    /** WebSocket URL for real-time feeds. Must be set explicitly to use createWebSocket(). */
+    wsUrl?: string;
+    /** Use Kalshi demo environment (https://demo-api.kalshi.co) when true. */
+    kalshiDemo?: boolean;
+    /** Optional auth request hooks used to enrich auth payloads. */
+    auth?: AggClientAuthOptions;
+    /** Move refresh delivery to an HttpOnly cookie on auth endpoints. Defaults to "body". */
+    authDelivery?: AggAuthDeliveryMode;
+    /** Persist a non-sensitive auth hint to localStorage for UI bootstrapping.
+     *  Tokens are NEVER persisted — they exist only in process memory.
+     *  When authDelivery is "body", refresh tokens are lost on page reload.
+     *  When authDelivery is "cookie-refresh", refresh tokens survive via HttpOnly cookies
+     *  and the SDK attempts a silent refresh on cold start. Defaults to true. */
+    persistSession?: boolean;
+}
+interface SiweMessageParams {
+    domain: string;
+    address: string;
+    uri: string;
+    nonce: string;
+    chainId?: number;
+    statement?: string;
+    issuedAt?: string;
+}
+interface SiwsMessageParams {
+    domain: string;
+    /** Base58-encoded Solana public key. */
+    address: string;
+    uri: string;
+    nonce: string;
+    /** Solana chain ID: "mainnet", "devnet", "testnet", or "localnet". Defaults to "mainnet". */
+    chainId?: string;
+    statement?: string;
+    issuedAt?: string;
+}
+/** OHLCV bar point for chart rendering. */
+interface ChartCandle {
+    /** Open time in Unix milliseconds. */
+    t: number;
+    /** Open price (0-1). */
+    o: number;
+    /** High price (0-1). */
+    h: number;
+    /** Low price (0-1). */
+    l: number;
+    /** Close price (0-1). */
+    c: number;
+    /** Volume (null if unavailable). */
+    v: number | null;
+}
+/** @deprecated Historical chart bars are canonical per outcome. Use ChartBarsResponse instead. */
+interface ChartVenueCandles {
+    venue: string;
+    candles: ChartCandle[];
+}
+type ChartResolution = "1m" | "5m" | "1h" | "1d";
+/**
+ * Freshness signal embedded in every chart response. Compare
+ * `staleSeconds` against the resolution to decide whether to show a
+ * "delayed" badge on the chart.
+ */
+interface ChartBarsMeta {
+    /** Server-side wall clock when the response was assembled, in milliseconds. */
+    serverTime: number;
+    /** `open_time` of the most-recent bar in `data`, in milliseconds. Null if `data` is empty. */
+    lastBarOpenTime: number | null;
+    /** `serverTime - lastBarOpenTime` in seconds. Null if `data` is empty. */
+    staleSeconds: number | null;
+}
+/** Response from GET /charts/bars. */
+interface ChartBarsResponse {
+    /** VenueMarketOutcome.id requested by the caller. */
+    venueMarketOutcomeId: string;
+    /** Venue of the canonical historical series. */
+    venue: string;
+    /** Resolution returned by the backend. */
+    resolution: ChartResolution;
+    /** Bars sorted in ascending open time. */
+    data: ChartCandle[];
+    /** Freshness signal — see {@link ChartBarsMeta}. */
+    meta: ChartBarsMeta;
+}
+/** Matched market reference returned by batch/aggregate endpoints. */
+interface VenueMarketRef {
+    venue: string;
+    venueMarketId: string;
+}
+type OrderbookBatchItemStatus = "ok" | "market_not_found" | "market_resolved" | "market_closed" | "market_paused" | "market_unopened" | "book_not_loaded";
+type OrderbookBatchItemErrorCode = "market_not_found" | "market_resolved" | "market_closed" | "market_paused" | "market_unopened" | "book_not_loaded";
+interface OrderbookBatchItemError {
+    code: OrderbookBatchItemErrorCode;
+    message: string;
+    retryable: boolean;
+}
+interface OrderbooksOnlyError {
+    code: "use_orderbooks_endpoint";
+    message: string;
+    retryable: boolean;
+}
+interface OrderbookServiceUnavailableError {
+    code: "orderbook_service_unavailable";
+    message: string;
+    retryable: boolean;
+}
+interface RequestedOrderbookMarket {
+    venueMarketId: string;
+    venue: string;
+    marketStatus: "open" | "closed" | "resolved" | "unopened" | "paused";
+    tickSize: number | null;
+    endDate: string | null;
+    resolutionDate: string | null;
+}
+interface MatchedOrderbookMarket extends VenueMarketRef {
+    marketStatus: "open" | "closed" | "resolved" | "unopened" | "paused";
+    tickSize: number | null;
+    hasOrderbook: boolean;
+}
+/**
+ * Provenance of a published `midpoint`. Mirrors the engine's `MarkSource`.
+ *
+ *  - `local`            — true two-sided midpoint from the venue's own book
+ *  - `local_merged`     — midpoint from the cross-venue merged book
+ *  - `local_one_sided`  — only one side present; mark is the live side, NOT a midpoint
+ *  - `sibling`          — derived from the complementary outcome (e.g. NO from YES)
+ *  - `local_boundary`   — clamped to the [tick, 1-tick] boundary
+ *  - `none`             — no mark available
+ */
+type MarkSource = "local" | "local_merged" | "local_one_sided" | "sibling" | "local_boundary" | "none";
+/** Per-venue orderbook entry with native tick spacing. */
+interface VenueOrderbookEntry {
+    venueMarketId: string;
+    tickSize: number | null;
+    orderbook: Orderbook;
+    /**
+     * Sticky tick of this venue's book inferred at runtime by the engine. May
+     * differ from the seed `tickSize` when the live grid is finer than the DB
+     * metadata. Optional — only populated when the engine has emitted runtime
+     * metadata for this entry.
+     */
+    tick?: number | null;
+    /** Provenance of this venue book's published midpoint. See {@link MarkSource}. */
+    markSource?: MarkSource;
+}
+/** Response from GET /orderbooks (batch). */
+interface BatchOrderbooksResponse {
+    data: Array<{
+        venueMarketId: string;
+        status: OrderbookBatchItemStatus;
+        error: OrderbookBatchItemError | null;
+        requestedMarket: RequestedOrderbookMarket | null;
+        venueOrderbooks: Record<string, VenueOrderbookEntry>;
+        matchedMarkets: MatchedOrderbookMarket[];
+    }>;
+    meta: {
+        requestedCount: number;
+        okCount: number;
+        errorCount: number;
+    };
+}
+/** A single market midpoint row returned by GET /midpoints. */
+interface MidpointRow {
+    venueMarketId: string;
+    venue: string;
+    midpoint: number | null;
+    spread: number | null;
+    timestamp: number | null;
+    /** Provenance of `midpoint`. */
+    markSource?: MarkSource;
+    /**
+     * When `markSource === "sibling"`, the matched venueMarketId whose book
+     * supplied the headline mark. Allows the FE to label "sourced from venue X"
+     * without re-running the matching logic.
+     */
+    siblingVenueMarketId?: string;
+}
+/** Per-outcome midpoint from a live orderbook. */
+interface OutcomeMidpointRow {
+    venueMarketOutcomeId: string;
+    label: string;
+    midpoint: number | null;
+    /** Provenance of `midpoint`. */
+    markSource?: MarkSource;
+}
+/** Response from GET /midpoints (batch). */
+interface BatchMidpointsResponse {
+    data: Array<MidpointRow & {
+        outcomes: OutcomeMidpointRow[];
+        matched: MidpointRow[];
+    }>;
+}
+/** Response from GET /orderbook/outcome/:id (single outcome). */
+interface OutcomeOrderbookResponse {
+    venueMarketOutcomeId: string;
+    venueMarketId: string;
+    venue: string;
+    orderbook: {
+        bids: Array<{
+            price: number;
+            size: number;
+        }>;
+        asks: Array<{
+            price: number;
+            size: number;
+        }>;
+    };
+    midpoint: number | null;
+    spread: number | null;
+    seq: number;
+    checksum: number;
+    timestamp: number;
+    /** Sticky tick of this outcome's book, inferred at runtime. `null` until inferred. */
+    tick: number | null;
+    /** Provenance of `midpoint`. See {@link MarkSource}. */
+    markSource: MarkSource;
+}
+/** Standard paginated list response from the API. */
+interface PaginatedResponse<T> {
+    data: T[];
+    nextCursor: string | null;
+    hasMore: boolean;
+}
+interface OrderListQuery {
+    userId?: string;
+    status?: string;
+    limit?: number;
+    offset?: number;
+}
+interface TradeExecutorOrder {
+    id: string;
+    userId: string;
+    venue: string;
+    status: string;
+    marketId: string;
+    tokenId: string;
+    side: string;
+    amountRaw: string;
+    quoteId: string | null;
+    dagRunId: string | null;
+    filledAmountRaw: string | null;
+    executionPrice: string | null;
+    txHash: string | null;
+    errorMessage: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface TradeExecutorOrderListResponse {
+    orders: TradeExecutorOrder[];
+    total: number;
+}
+/** A single level in the aggregated orderbook with per-venue attribution. */
+interface AggregatedOrderbookLevel {
+    price: number;
+    size: number;
+    venues: Record<string, number>;
+}
+/** A simple orderbook level without venue attribution. */
+interface SimpleOrderbookLevel {
+    price: number;
+    size: number;
+}
+/** Per-venue best-bid/ask info. */
+interface VenuePriceInfo {
+    bestBid: number | null;
+    bestAsk: number | null;
+}
+/** Response from GET /orderbook/:venueMarketId — canonical aggregated orderbook. */
+interface AggregatedOrderbookResponse {
+    venueMarketId: string;
+    orderbook: {
+        bids: AggregatedOrderbookLevel[];
+        asks: AggregatedOrderbookLevel[];
+    };
+    venueOrderbooks: Record<string, {
+        bids: SimpleOrderbookLevel[];
+        asks: SimpleOrderbookLevel[];
+    }>;
+    venues: Record<string, VenuePriceInfo>;
+    midpoint: number | null;
+    spread: number | null;
+    timestamp: number;
+    /** Sequence number (present in live responses). */
+    seq?: number;
+    /** CRC32 checksum (present in live responses). */
+    checksum?: number | null;
+    /** Markets matched across venues for this canonical market. */
+    matchedMarkets?: Array<{
+        venue: string;
+        venueMarketId: string;
+    }>;
+}
+interface QuoteManagedParams {
+    venueMarketOutcomeIds: string[];
+    side: "buy" | "sell";
+    amount: number;
+    slippageBps?: number;
+}
+interface QuoteManagedStep {
+    type: string;
+    description: string;
+    estimatedDurationMs: number;
+}
+interface QuoteManagedSplit {
+    venue: string;
+    venueMarketId: string;
+    venueMarketOutcomeId: string;
+    tokenId: string;
+    price: string;
+    size: string;
+    costRaw: string;
+}
+interface QuoteManagedResponse {
+    quoteId: string;
+    canExecute: boolean;
+    estimatedCostRaw: string;
+    steps: QuoteManagedStep[];
+    splits: QuoteManagedSplit[];
+    expiresAt: string;
+}
+interface ExecuteManagedParams {
+    quoteId: string;
+}
+interface ExecuteManagedResponse {
+    quoteId: string;
+    orderIds: string[];
+    status: "pending";
+}
+interface ValidateManagedParams {
+    venueMarketOutcomeIds: string[];
+    side: "buy" | "sell";
+    amount: number;
+}
+interface ValidateManagedResponse {
+    canExecute: boolean;
+    availableBalanceRaw: string;
+    requiredBalanceRaw: string;
+    bridgeSourceChainId?: number;
+    bridgeAmountRaw?: string;
+}
+interface WithdrawManagedParams {
+    amountRaw: string;
+    tokenSymbol: string;
+    destinationAddress: string;
+    destinationChainId?: number;
+}
+interface WithdrawManagedSourceItem {
+    chainId: number;
+    amountRaw: string;
+    txHash?: string;
+    bridgeOperationId?: string;
+}
+interface WithdrawManagedResponse {
+    sources: WithdrawManagedSourceItem[];
+}
+interface DepositAddressesToken {
+    symbol: string;
+    address: string;
+    decimals: number;
+}
+interface DepositAddressesSupportedChain {
+    chainId: number;
+    name: string;
+    tokens: DepositAddressesToken[];
+}
+interface DepositAddressesReadyResponse {
+    ready: true;
+    evmAddress: string;
+    svmAddress: string;
+    supportedChains: DepositAddressesSupportedChain[];
+}
+interface DepositAddressesPendingResponse {
+    ready: false;
+}
+type DepositAddressesResponse = DepositAddressesReadyResponse | DepositAddressesPendingResponse;
+interface GetPositionsParams {
+    cursor?: string;
+    limit?: number;
+    status?: "active" | "closed";
+}
+interface GetOrdersParams {
+    status?: string;
+    cursor?: string;
+    limit?: number;
+}
+interface OrderbookQuoteParams {
+    marketId: string;
+    side: "buy" | "sell";
+    size: number;
+}
+interface OrderbookQuoteFill {
+    venue: string;
+    size: number;
+    avgPrice: number;
+    cost: number;
+}
+interface OrderbookQuoteResponse {
+    marketId: string;
+    side: "buy" | "sell";
+    requestedSize: number;
+    filledSize: number;
+    avgPrice: number | null;
+    totalCost: number;
+    slippage: number | null;
+    fills: OrderbookQuoteFill[];
+}
+type ExecutionOrdersQuery = GetOrdersQuery;
+type ExecutionOrderItem = OrderListItem;
+type ExecutionPositionsQuery = GetPositionsQuery;
+type ExecutionPositionGroup = PositionGroup;
+type UserActivityType = "trade" | "withdrawal" | "bridge" | "deposit" | "user_op";
+interface UserActivityBase {
+    id: string;
+    createdAt: string;
+    updatedAt: string;
+    status: string;
+}
+interface UserActivityVenueMarket {
+    id: string;
+    venueEventId: string;
+    question: string | null;
+    image: string | null;
+}
+interface UserActivityVenueMarketOutcome {
+    id: string;
+    label: string;
+    title: string | null;
+    price: number;
+}
+interface UserActivityTrade extends UserActivityBase {
+    type: "trade";
+    venue: string;
+    side: string;
+    amountRaw: string;
+    filledAmountRaw: string | null;
+    executionPrice: string | null;
+    venueMarket: UserActivityVenueMarket | null;
+    venueMarketOutcome: UserActivityVenueMarketOutcome | null;
+    txHash: string | null;
+    errorMessage: string | null;
+    /** @deprecated Use venueMarket.question. */
+    marketQuestion?: string | null;
+    /** @deprecated Use venueMarketOutcome.label/title. */
+    outcomeLabel?: string | null;
+}
+interface UserActivityWithdrawal extends UserActivityBase {
+    type: "withdrawal";
+    tokenSymbol: string;
+    amountRaw: string;
+    destinationAddress: string;
+    destinationChainId: string;
+    completedAmountRaw: string | null;
+    errorMessage: string | null;
+}
+interface UserActivityBridge extends UserActivityBase {
+    type: "bridge";
+    tokenSymbol: string;
+    amountRaw: string;
+    sourceChainId: string;
+    destChainId: string;
+    sourceTxHash: string | null;
+    destTxHash: string | null;
+}
+interface UserActivityDeposit extends UserActivityBase {
+    type: "deposit";
+    tokenSymbol: string;
+    amountRaw: string;
+    chainId: string;
+    fromAddress: string;
+    txHash: string;
+}
+interface UserActivityUserOp extends UserActivityBase {
+    type: "user_op";
+    callsId: string;
+    chainId: string;
+    walletAddress: string;
+    txHash: string | null;
+    confirmedAt: string | null;
+}
+type UserActivityItem = UserActivityTrade | UserActivityWithdrawal | UserActivityBridge | UserActivityDeposit | UserActivityUserOp;
+interface UserActivityQuery {
+    type?: UserActivityType;
+    cursor?: string;
+    limit?: number;
+}
+interface RampQuoteRequest {
+    sourceAmount: string;
+    sourceCurrencyCode: string;
+    destinationCurrencyCode: string;
+    paymentMethodType?: string;
+}
+interface RampQuote {
+    serviceProvider: string;
+    transactionType: string;
+    sourceAmount: number;
+    sourceCurrencyCode: string;
+    destinationAmount: number;
+    destinationCurrencyCode: string;
+    exchangeRate: number;
+    totalFee: number;
+    networkFee: number;
+    transactionFee: number;
+    partnerFee: number;
+    fiatAmountWithoutFees: number;
+    paymentMethodType: string;
+    countryCode: string;
+    rampScore: number;
+    lowKyc: boolean;
+}
+interface RampSessionRequest {
+    sourceAmount: string;
+    sourceCurrencyCode: string;
+    destinationCurrencyCode: string;
+    serviceProvider: string;
+    walletAddress: string;
+    redirectUrl?: string;
+}
+interface RampWidgetSession {
+    id: string;
+    token: string;
+    widgetUrl: string;
+    serviceProviderWidgetUrl: string;
+}
+type SmartRouteStatus = "ok" | "infeasible" | "checker_rejected" | "solver_error" | "invalid_input" | "no_orderbooks" | "min_order_size_violated" | "insufficient_input_amount" | "engine_unavailable" | "insufficient_position" | "insufficient_depth" | "no_bids_above_min_price" | "insufficient_balance";
+/** A single fill at a price level within a venue. */
+interface SmartRouteFill {
+    price: number;
+    size: number;
+    fill: number;
+}
+/** Per-venue routing result with fills and chain info. */
+interface SmartRouteVenueFill {
+    venue: string;
+    venueMarketId: string;
+    venueMarketOutcomeId: string;
+    chain: string;
+    avgPrice: number;
+    yesPrice: number;
+    noPrice: number;
+    fills: SmartRouteFill[];
+    venueQty: number;
+}
+interface VenueSoloQuote {
+    /**
+     * Minted by the API per successful + executable solo; send this to
+     * /execution/fill to execute single-venue. `null` when the solo is not
+     * executable (status !== "ok", filledQty === 0, or venue not in
+     * SUPPORTED_FILL_VENUES). FE filters on truthiness.
+     */
+    quoteId: string | null;
+    venue: string;
+    avgPrice: number | null;
+    filledQty: number;
+    rawExecCost: number;
+    estimatedPayout: number;
+    estimatedProfit: number;
+    returnPct: number;
+    status: string;
+    /** Per-price-level fills, identical shape to primary fills. Empty for non-ok statuses. */
+    fills: SmartRouteVenueFill[];
+}
+/** @deprecated Smart-route side overrides are kept only for source compatibility. */
+type SmartRouteSide = "yes" | "no";
+/** Trade direction for order routing. "buy" (default) reads asks, "sell" reads bids. */
+type TradeSide = "buy" | "sell";
+/** Request params for GET /orderbook/:venueMarketOutcomeId/route. */
+interface SmartRouteParams {
+    venueMarketOutcomeId?: string;
+    /** @deprecated Use venueMarketOutcomeId. */
+    venueMarketId?: string;
+    /** @deprecated Use venueMarketOutcomeId. */
+    outcomeId?: string;
+    /** @deprecated Side is ignored for routing and echoed back only for legacy consumers. */
+    side?: SmartRouteSide;
+    /** Trade direction: "buy" (default) or "sell". */
+    tradeSide?: TradeSide;
+    maxSpend?: number;
+    /** Sell only: target number of contracts to sell. Required for sell unless maxSpend is given. */
+    sellShares?: number;
+    chainBalances?: Record<string, number>;
+    slipCapBps?: number;
+    compareVenues?: boolean;
+}
+/** Response from GET /orderbook/:venueMarketOutcomeId/route. */
+interface SmartRouteResponse {
+    quoteId: string;
+    venueMarketOutcomeId: string;
+    venueMarketId: string;
+    estimatedCostRaw: string;
+    expiresAt: string;
+    status: SmartRouteStatus;
+    fills: SmartRouteVenueFill[];
+    totalFilled: number;
+    rawExecCost: number;
+    solveTimeMs: number;
+    verifyTimeMs: number;
+    matchedMarkets: Array<{
+        venue: string;
+        venueMarketId: string;
+    }>;
+    error?: string;
+    message?: string;
+    warnings?: Array<{
+        venue: string;
+        venueMarketOutcomeId: string;
+        reason: string;
+    }>;
+    venueSoloQuotes?: VenueSoloQuote[];
+    /** Estimated payout if the outcome wins (= totalFilled shares × $1). */
+    estimatedPayout?: number;
+    /** Total cost including all fees (rawExecCost + venueFees + bridgeFees + executionGas). */
+    totalCostIncFees?: number;
+    /** Estimated profit if the outcome wins (= estimatedPayout − totalCostIncFees). */
+    estimatedProfit?: number;
+    /** Return on investment percentage (= estimatedProfit / totalCostIncFees × 100). */
+    returnPct?: number;
+    /** Populated only when status === "insufficient_position". */
+    positionAvailability?: {
+        totalSellableShares: number;
+        venueMarketOutcomes: Array<{
+            id: string;
+            venue: string;
+            venueMarketId: string;
+            availableShares: number;
+        }>;
+    };
+    /** @deprecated Echoed only when the deprecated request-side override is provided. */
+    side?: SmartRouteSide;
+}
+interface CancelManagedExecutionResponse {
+    quoteId: string;
+    orderIds: string[];
+    status: "cancelled";
+}
+type PositionRedeemStatus = "eligible" | "pending" | "redeemed" | "ineligible";
+type RedeemLegStatus = "submitted" | "confirmed" | "ineligible" | "rejected";
+interface RedeemLegResult {
+    venueMarketOutcomeId: string;
+    status: RedeemLegStatus;
+    callsId: string | null;
+    pendingUserOpId: string | null;
+    txHash: string | null;
+    reason: string | null;
+}
+interface RedeemRequest {
+    venueMarketOutcomeIds: string[];
+}
+interface RedeemResponse {
+    redeemId: string;
+    results: RedeemLegResult[];
+}
+type SearchType = "events" | "markets";
+interface SearchParams {
+    q: string;
+    type: SearchType;
+    categoryIds?: string[];
+    limit?: number;
+    cursor?: string;
+}
+type SearchResponse<T> = {
+    type: SearchType;
+    data: T[];
+    nextCursor: string | null;
+    hasMore: boolean;
+};
+
+type AuthStateListener = (authenticated: boolean) => void;
+type UserAuthResult = {
+    accessToken: string;
+    refreshToken?: string;
+    user: UserProfile;
+};
+declare class AggClient {
+    private appId?;
+    private adminKey?;
+    private apiKey?;
+    private baseUrl;
+    private accessToken?;
+    private refreshTokenValue?;
+    private currentUser?;
+    private listeners;
+    private storageKey;
+    private shouldPersistSession;
+    private authDelivery;
+    private wsUrl?;
+    private _authStatus;
+    private authChannel;
+    private authOptions?;
+    /** In-flight refresh promise — serializes concurrent 401 retries so only one refresh runs. */
+    private pendingRefresh;
+    constructor(options: AggClientOptions);
+    private withAuthPayload;
+    private restoreSession;
+    private persistSession;
+    private initAuthChannel;
+    /** Release resources (BroadcastChannel, etc.). Safe to call multiple times. */
+    destroy(): void;
+    /**
+     * Generic HTTP method with automatic header injection and 401 retry.
+     * Attaches `x-app-id`, `Authorization: Bearer`, and `x-admin-key` headers as appropriate.
+     * On 401, attempts a single token refresh and retries the request.
+     * @param path - API path (e.g. `/venue-events`)
+     * @param init - Fetch init options, plus optional `query` object for URL search params
+     */
+    request<T>(path: string, init?: RequestInit & {
+        query?: Record<string, string | string[]>;
+    }): Promise<T>;
+    private rawFetch;
+    private throwResponseError;
+    /**
+     * Deduplicates concurrent refresh attempts — if multiple requests hit 401 at the same time,
+     * only one refresh call is made and the rest wait for it.
+     */
+    private refreshWithDedup;
+    private buildAuthRequestInit;
+    private buildUserAuthResult;
+    private performSignOutRequest;
+    /** Set the user access token (for future user-tier auth). */
+    setAccessToken(token: string): void;
+    /** Set the current auth session tokens and optionally seed the user profile. */
+    setSession(session: AggClientSessionInput): void;
+    /** Clear the user access token, refresh token, and user info. Broadcasts cross-tab logout. */
+    clearAccessToken(): void;
+    private broadcastAuth;
+    /** Current auth lifecycle status. */
+    get authStatus(): AuthStatus;
+    /** Whether a user access token is currently set. */
+    get isAuthenticated(): boolean;
+    /** Primary wallet address derived from the current user profile. */
+    get address(): string | undefined;
+    /** Subscribe to auth state changes. Returns an unsubscribe function. */
+    onAuthStateChange(listener: AuthStateListener): () => void;
+    private notifyListeners;
+    /** Get the currently authenticated user, if any. */
+    get user(): UserProfile | undefined;
+    /** Build an EIP-4361 SIWE message string (pure formatting, no crypto). */
+    buildSiweMessage(params: SiweMessageParams): string;
+    /** Build a SIWS message string for Solana wallet sign-in (pure formatting, no crypto). */
+    buildSiwsMessage(params: SiwsMessageParams): string;
+    /** Verify a SIWE/SIWS signature with the API, store the token + user. */
+    verify(args: AggAuthVerifyBody): Promise<UserAuthResult>;
+    /** Backwards-compatible alias for `verify()`. */
+    verifySignIn(args: AggAuthVerifyBody): Promise<UserAuthResult>;
+    /** Initiate an auth flow (SIWE nonce, OAuth redirect URL, or magic link). */
+    authStart(body: AggAuthStartBody): Promise<AggAuthStartResult>;
+    /** Backwards-compatible alias for `authStart()`. */
+    startAuth(body: AggAuthStartBody): Promise<AggAuthStartResult>;
+    /**
+     * Start an account-link flow. Requires the caller to already be signed in — sends
+     * the bearer automatically. Response shape:
+     *  - OAuth providers → `{ type: "redirect", url }`; redirect the browser to `url`.
+     *  - Email → `{ type: "magic_link", success: true }`; check the destination inbox.
+     *
+     * After the provider callback runs, the browser lands back on the app's `redirectUrl`
+     * with a `link_confirm_token` query param. Feed that token to `linkAccountConfirm()`
+     * to persist the Account row.
+     *
+     * Wallet linking (siwe/siws) is not supported yet — it requires a different message
+     * binding protocol than sign-in to be safe against signature phishing.
+     */
+    linkAccount(body: AggLinkAccountBody): Promise<AggLinkAccountResult>;
+    /**
+     * Exchange a `link_confirm_token` for a linked `Account` row. The server matches
+     * the current bearer's `principalId` to the token's `principalId` before writing —
+     * this is the final ownership check.
+     */
+    linkAccountConfirm(token: string): Promise<AggLinkAccountConfirmResult>;
+    /** Exchange a one-time auth code (from OAuth/magic-link callback) for tokens. */
+    exchangeAuthCode(code: string): Promise<UserAuthResult>;
+    /** Refresh the access token using the stored refresh token. */
+    refreshAccessToken(): Promise<string>;
+    /** Get the current user's profile. */
+    getCurrentUser(): Promise<UserProfile>;
+    /** Update the current user (e.g. username). Requires currentUser.id; call getCurrentUser() first if needed. */
+    updateUser(data: UpdateUserBody): Promise<UserProfile>;
+    /** Link a partner-provided external user ID assertion to the current user. */
+    linkExternalId(params: {
+        externalId: string;
+        timestamp: number;
+        hmac: string;
+    }): Promise<UserProfile>;
+    /** Create a presigned avatar upload URL for the current user. */
+    createAvatarUploadUrl(contentType: string): Promise<{
+        uploadUrl: string;
+        assetKey: string;
+        cdnUrl: string;
+    }>;
+    /** Disconnect a linked auth provider from the current user. */
+    disconnectAccount(provider: "wallet" | "solana_wallet" | "google" | "twitter" | "apple" | "email"): Promise<{
+        success: true;
+    }>;
+    /** Sign out — revoke all tokens server-side and clear local session. */
+    signOut(): Promise<void>;
+    /** Get user holdings (positions) for a venue. Uses backend to resolve venue-specific identifiers. */
+    getUserHoldings(params: {
+        venue: Venue;
+        venueMarketId?: string;
+        venueEventId?: string;
+        cursor?: string;
+    }): Promise<PaginatedResponse<UserHolding>>;
+    /** List trade-executor orders for the authenticated user. */
+    getOrders(params?: OrderListQuery): Promise<TradeExecutorOrderListResponse>;
+    /** List execution orders for the authenticated user (cursor pagination). */
+    getExecutionOrders(params?: ExecutionOrdersQuery): Promise<PaginatedResponse<ExecutionOrderItem>>;
+    /** Unified user activity feed (trades, deposits, withdrawals, bridges, wallet ops). */
+    getUserActivity(params?: UserActivityQuery): Promise<PaginatedResponse<UserActivityItem>>;
+    /** List execution positions for the authenticated user (cursor pagination). */
+    getExecutionPositions(params?: ExecutionPositionsQuery): Promise<PaginatedResponse<ExecutionPositionGroup>>;
+    /** Get managed wallet balances, including per-chain cash balances and per-venue position balances. */
+    getManagedBalances(): Promise<UnifiedBalanceResponse>;
+    /** Cancel a pending managed execution by order id. */
+    cancelManagedOrder(orderId: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<CancelManagedExecutionResponse>;
+    /** List venue events with optional filters. Requires appId or admin auth. Supports cursor-based pagination. */
+    getVenueEvents(options?: {
+        venues?: Venue[];
+        search?: string;
+        categoryIds?: string[];
+        matchStatus?: MatchStatus[];
+        status?: MarketStatus[];
+        sortBy?: string;
+        sortDir?: string;
+        limit?: number;
+        cursor?: string;
+        minYesPrice?: number;
+        maxYesPrice?: number;
+        /** ISO-8601 timestamp. Hides events with endDate <= this value. NULL-endDate events are kept. */
+        endDateFrom?: string;
+    }): Promise<PaginatedResponse<VenueEvent>>;
+    /** Get a single venue event by ID. Requires appId or admin auth. */
+    getVenueEventById(id: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<VenueEvent>;
+    /** List venue markets with optional filters. Requires appId or admin auth. Supports cursor-based pagination. */
+    getVenueMarkets(options?: {
+        venue?: Venue;
+        venueEventId?: string;
+        search?: string;
+        matchStatus?: MatchStatus;
+        status?: MarketStatus;
+        categoryIds?: string[];
+        limit?: number;
+        cursor?: string;
+        sortBy?: "volume" | "volume24hr" | "createdAt" | "yesPrice" | "updatedAt";
+        sortDir?: "asc" | "desc";
+    }): Promise<PaginatedResponse<VenueMarket>>;
+    /** Get categories with cursor-based pagination. Requires appId. */
+    getCategories(options?: {
+        limit?: number;
+        cursor?: string;
+    }): Promise<PaginatedResponse<Category>>;
+    /** Get per-app UI config (disabled venues + category presets). Requires appId. */
+    getAppConfig(init?: RequestInit): Promise<AppClientConfigResponse>;
+    /** Search events or markets by query string. Supports cursor-based pagination. */
+    search<T = VenueEvent>(params: SearchParams): Promise<SearchResponse<T>>;
+    /** Get the canonical TradingView-style bar series for a single venue market outcome. */
+    getChartBars(params: {
+        venueMarketOutcomeId: string;
+        resolution?: ChartResolution;
+        from?: number;
+        to: number;
+        countBack?: number;
+    }, options?: {
+        signal?: AbortSignal;
+    }): Promise<ChartBarsResponse>;
+    /** Get live per-venue orderbooks for the explicit venueMarketIds requested. */
+    getOrderbooks(params: {
+        venueMarketIds: string[];
+        depth?: number;
+    }, options?: {
+        signal?: AbortSignal;
+    }): Promise<BatchOrderbooksResponse>;
+    /** Get live midpoints for the explicit venueMarketIds requested. */
+    getMidpoints(params: {
+        venueMarketIds: string[];
+    }, options?: {
+        signal?: AbortSignal;
+    }): Promise<BatchMidpointsResponse>;
+    getMidpoints(venueMarketIds: string[], options?: {
+        signal?: AbortSignal;
+    }): Promise<BatchMidpointsResponse>;
+    /** Get a single outcome-level orderbook from the engine. */
+    getOutcomeOrderbook(outcomeId: string, options?: {
+        depth?: number;
+        signal?: AbortSignal;
+    }): Promise<OutcomeOrderbookResponse | null>;
+    /**
+     * Compute optimal order routing across venues via the MILP solver.
+     * Returns a user-scoped quote with per-venue fills and verification timing.
+     * Deprecated aliases are accepted for source compatibility during the
+     * outcome-level migration window.
+     */
+    getSmartRoute(params: SmartRouteParams, options?: {
+        signal?: AbortSignal;
+    }): Promise<SmartRouteResponse>;
+    /**
+     * Create an AggWebSocket instance configured with this client's appId and optional auth token.
+     * Requires `wsUrl` to be set in the client options.
+     */
+    createWebSocket(callbacks?: AggWebSocketCallbacks, options?: {
+        enableLogs?: boolean;
+    }): AggWebSocket;
+    /** Request a quote for a managed trade. Returns quoteId (2-min TTL), execution steps, and splits. */
+    quoteManaged(params: QuoteManagedParams): Promise<QuoteManagedResponse>;
+    /** Execute a previously quoted managed trade. Returns pending order IDs. */
+    executeManaged(params: ExecuteManagedParams): Promise<ExecuteManagedResponse>;
+    /** Redeem resolved winning positions by venue market outcome ids. */
+    redeem(body: RedeemRequest): Promise<RedeemResponse>;
+    /** Withdraw funds from managed wallets to an external address. */
+    withdrawManaged(params: WithdrawManagedParams): Promise<WithdrawManagedResponse>;
+    /** Trigger an on-chain balance sync for all tracked tokens across all chains. */
+    syncManagedBalances(): Promise<SyncBalancesResponse>;
+    /** Get managed wallet deposit addresses (EVM + Solana). Returns 202 shape while provisioning. */
+    getDepositAddresses(): Promise<DepositAddressesResponse>;
+    /** Get open positions grouped by matched market with per-venue breakdown. */
+    getPositions(params?: GetPositionsParams): Promise<PaginatedResponse<PositionGroup>>;
+    /** Get crypto purchase quotes. */
+    getRampQuotes(params: RampQuoteRequest): Promise<RampQuote[]>;
+    /** Create a ramp widget session for checkout. */
+    createRampSession(params: RampSessionRequest): Promise<RampWidgetSession>;
+    /** Initiate KYC verification for a venue. Returns a KYC URL to redirect the user to. */
+    initiateKyc(venue: string, redirectUri: string): Promise<{
+        status: string;
+        kycUrl?: string;
+    }>;
+}
+
+declare const computeBestSplitsByAmount: typeof computeBestSplitsByAmount$1;
+
+/**
+ * Thrown when the server returns `challenge_required` during auth start.
+ * The client should render a Cloudflare Turnstile widget using `siteKey`,
+ * then retry the auth flow with the resulting `turnstileToken`.
+ */
+declare class TurnstileChallengeError extends Error {
+    readonly siteKey: string;
+    constructor(siteKey: string);
+}
+
+type CandleInterval = "1m" | "5m" | "1h" | "1d";
+/** Universal OHLCV candle. Chart-library-agnostic. */
+interface Candle {
+    /** Interval-aligned open time in seconds. */
+    openTime: number;
+    o: number;
+    h: number;
+    l: number;
+    c: number;
+    /** Accumulated trade volume. 0 if no trades in interval. */
+    v: number;
+    tradeCount: number;
+    isFinal: boolean;
+}
+/**
+ * Accumulates OHLCV candles from orderbook delta midpoints and trades.
+ * All 4 intervals computed simultaneously. onChange batched via rAF (~16ms).
+ */
+declare class CandleBuilder {
+    private forming;
+    private closedMap;
+    private listeners;
+    private _midpoint;
+    private dirty;
+    private scheduled;
+    constructor();
+    /** Feed a midpoint (from orderbook delta). Updates O/H/L/C for all intervals. */
+    addMidpoint(midpoint: number, timestampSecs: number): void;
+    /** Feed a trade. Updates volume + refines H/L/C from trade price. */
+    addTrade(price: number, size: number, timestampSecs: number): void;
+    /** Current forming candle for an interval. */
+    getForming(interval: CandleInterval): Candle | null;
+    /** Closed candles for an interval (ring buffer, max 500, newest last). */
+    getClosed(interval: CandleInterval): Candle[];
+    /** Current midpoint (latest value fed). */
+    get midpoint(): number | null;
+    /**
+     * Subscribe to state changes. Returns unsubscribe function.
+     * BATCHED: callbacks fire at most once per rAF frame (~16ms).
+     * In non-browser environments, falls back to 16ms setTimeout.
+     */
+    onChange(listener: () => void): () => void;
+    /** Clear all state (on reconnect). */
+    reset(): void;
+    /** Clear all state AND unsubscribe all listeners. Called on store eviction. */
+    dispose(): void;
+    private updateCandle;
+    private markDirty;
+}
+
+/**
+ * Merge forming candles from matched venues into one aggregate.
+ * Open/Close: volume-weighted average (simple average if all v=0).
+ * High: max across venues. Low: min across venues. Volume: sum.
+ */
+declare function mergeCandles(candles: (Candle | null | undefined)[]): Candle | null;
+/**
+ * Merge arrays of closed candles from multiple venues, aligned by openTime.
+ * For each openTime present in ANY venue, produces one merged candle.
+ */
+declare function mergeClosedCandles(candleArrays: Candle[][]): Candle[];
+/** Simple average of available midpoints. */
+declare function aggregateMidpoint(midpoints: (number | null | undefined)[]): number | null;
+
+declare function createAggClient(options: AggClientOptions): AggClient;
+
+export { type Account, AccountProvider, AccountType, type AggAuthDeliveryMode, type AggAuthProviderType, type AggAuthStartBody, type AggAuthStartResult, type AggAuthVerifyBody, AggClient, type AggClientAuthOptions, type AggClientSessionInput, type AggLinkAccountBody, type AggLinkAccountConfirmResult, type AggLinkAccountResult, type AggSessionUser, AggWebSocket, type AggWebSocketCallbacks, type AggWebSocketOptions, type AggregatedOrderbookLevel, type AggregatedOrderbookResponse, type App, type AppClientConfigResponse, type AttributedOrderbook, type AttributedOrderbookLevel, type AuthCodeResponse, type AuthStatus, type AuthTokenResponse, type AuthUser, type BatchMidpointsResponse, type BatchOrderbooksResponse, CONFIRMED_MATCH_STATUSES, type CancelManagedExecutionResponse, type Candle, CandleBuilder, type CandleInterval, type Category, Chain, type ChartBarsResponse, type ChartCandle, type ChartResolution, type ChartVenueCandles, type ComputeSplitsRequest, type ComputeSplitsResponse, type ComputeSplitsSelection, type CreateApp, type DepositAddressesPendingResponse, type DepositAddressesReadyResponse, type DepositAddressesResponse, type DepositAddressesSupportedChain, type DepositAddressesToken, type DepositStep, type DiagnosticCallback, type DiagnosticEvent, type ExecuteManagedParams, type ExecuteManagedRequest, type ExecuteManagedResponse, type ExecuteTradeRequest, type ExecuteTradeResponse, type ExecutionOrderItem, type ExecutionOrdersQuery, type ExecutionPositionGroup, type ExecutionPositionsQuery, type GetBalanceQuery, type GetBalanceResponse, type GetHoldingsQuery, type GetHoldingsResponse, type GetOrdersParams, type GetOrdersQuery, type GetPositionsParams, type GetPositionsQuery, type HelloResponse, IMAGE_SIZES, ImageSize, type MarkSource, type MarketPriceHistory, MarketStatus, MatchStatus, MatchType, type MatchedMidpoint, type MatchedOrderbookMarket, type MatchingReport, type MidpointItem, type MidpointRow, type NonceResponse, type OrderListItem, type OrderListQuery, OrderStatus, type Orderbook, type OrderbookBatchItemError, type OrderbookBatchItemErrorCode, type OrderbookBatchItemStatus, type OrderbookHistoryPoint, type OrderbookHistoryResponse, type OrderbookLevel, type OrderbookQuoteFill, type OrderbookQuoteParams, type OrderbookQuoteResponse, type OrderbookServiceUnavailableError, type OrderbookState, type OrderbooksOnlyError, type OutcomeMidpoint, type OutcomeMidpointRow, type OutcomeOrderbookResponse, type PaginatedResponse, type PersistedAuthSnapshot, type PositionGroup, type PositionRedeemStatus, type PricePoint, type PricesHistoryResponse, type QuoteManagedParams, type QuoteManagedRequest, type QuoteManagedResponse, type QuoteManagedSplit, type QuoteManagedStep, type QuoteSplit, type QuoteStep, type RampQuote, type RampQuoteRequest, type RampSessionRequest, type RampWidgetSession, type RedeemLegResult, type RedeemLegStatus, type RedeemRequest, type RedeemResponse, type RequestedOrderbookMarket, type SafeParseFailure, type SafeParseResult, type SafeParseSuccess, type ServerWallet, type SettlementSource, type SetupDepositAddressStep, type SetupVenueKeyStep, type SimpleOrderbookLevel, type SmartRouteFill, type SmartRouteParams, type SmartRouteResponse, type SmartRouteSide, type SmartRouteStatus, type SmartRouteVenueFill, type SplitsByAmountResult, type SyncBalancesResponse, type TradeExecutorOrder, type TradeExecutorOrderListResponse, TradeSide$1 as TradeSide, type TradeSplit, type TradeStep, TurnstileChallengeError, type UnifiedBalanceResponse, type UpdateUserBody, type UpsertVenueKey, type UserActivityBridge, type UserActivityDeposit, type UserActivityItem, type UserActivityQuery, type UserActivityTrade, type UserActivityType, type UserActivityUserOp, type UserActivityWithdrawal, type UserHolding, type UserProfile, VENUES, type ValidateBalanceOnClientStep, type ValidateManagedParams, type ValidateManagedRequest, type ValidateManagedResponse, type ValidateTradeRequest, type ValidateTradeResponse, Venue, type VenueEvent, type VenueEventListItem, type VenueEventWithMarkets, type VenueKeySummary, type VenueMarket, type VenueMarketClusterNode, type VenueMarketListItem, type VenueMarketOutcome, type VenueMarketRef, type VenueOrderbookEntry, type VenueOrderbookLevel, type VenuePositionBalance, type VenuePriceInfo, type VenueSoloQuote, type VerifyBody, type VerifyResponse, type WalletChainBalance, type WalletTokenBalance, type WithdrawManagedParams, type WithdrawManagedRequest, type WithdrawManagedResponse, type WithdrawManagedSourceItem, type WithdrawalSource, type WsAttributedLevel, type WsAuthenticated, type WsBalanceUpdate, type WsCandleInterval, type WsClientMessage, type WsConnected, type WsError, type WsHeartbeat, type WsMarkSource, type WsMarketResolved, type WsOrderEvent, type WsOrderEventType, type WsOrderSubmitted, type WsOrderbookDelta, type WsOrderbookSnapshot, type WsRedeemEvent, type WsServerMessage, type WsSubscribed, type WsTrade, type WsUnsubscribed, type WsVenueBook, type WsVenueInfo, type WsVenueLevel, aggregateMidpoint, applyOrderbookDelta, computeBestSplitsByAmount, computeChecksum, createAggClient, enumGuard, formatMarketQuestion, formatOutcomeLabel, getWalletAddressFromUserProfile, hasShape, isEmail, isEnum, isFiniteNonNeg, isNonEmptyString, mergeCandles, mergeClosedCandles, normalizeVenueMarketCluster, optimizedImageUrl, parse, parseEmail, parseEmailStrict, safeParse, snapshotToOrderbook, sortVenues };