@outcome.xyz/hip4 1.0.0-beta

package/dist/index-ubGjjLVg.d.ts

@@ -0,0 +1,799 @@
+/** An open position in a prediction market outcome. */
+interface PredictionPosition {
+    marketId: string;
+    eventTitle: string;
+    marketQuestion: string;
+    /** Coin identifier (e.g. "#90" or "#91"). Use for lookups. */
+    outcome: string;
+    /** Human-readable side name from sideSpecs (e.g. "Hypurr", "Yes"). Use for display. */
+    outcomeName: string;
+    shares: string;
+    avgCost: string;
+    currentPrice: string;
+    unrealizedPnl: string;
+    potentialPayout: string;
+    eventStatus: "active" | "pending_resolution" | "resolved";
+}
+/** A historical account activity entry (trade, redeem, deposit, or withdrawal). */
+interface PredictionActivity {
+    id: string;
+    type: "trade" | "redeem" | "deposit" | "withdrawal";
+    marketId?: string;
+    outcome?: string;
+    side?: "buy" | "sell";
+    price?: string;
+    size?: string;
+    amount?: string;
+    timestamp: number;
+}
+/** Current authentication state for the trading adapter. */
+interface PredictionAuthState {
+    status: "disconnected" | "pending_approval" | "ready";
+    address?: string;
+    apiKey?: string;
+}
+
+/** A prediction event containing one or more markets. */
+interface PredictionEvent {
+    /** Unique event ID (e.g. "q123" for questions, "o456" for standalone outcomes). */
+    id: string;
+    title: string;
+    description: string;
+    category: string;
+    markets: PredictionMarket[];
+    /** Cumulative volume across all markets in the event. */
+    totalVolume: string;
+    endDate: string;
+    status: PredictionEventStatus;
+    imageUrl?: string;
+    resolutionSource?: string;
+}
+type PredictionEventStatus = "active" | "pending_resolution" | "resolved" | "cancelled";
+/** A single market (question) within a prediction event. */
+interface PredictionMarket {
+    id: string;
+    eventId: string;
+    question: string;
+    outcomes: PredictionOutcome[];
+    volume: string;
+    liquidity: string;
+    /** True if this market uses neg-risk framing. */
+    isNegRisk?: boolean;
+}
+/** One side of a prediction market (e.g. "Yes" or "No"). */
+interface PredictionOutcome {
+    name: string;
+    /** The spot token ID used for trading this outcome. */
+    tokenId: string;
+    /** Current price as a decimal string (0-1). */
+    price: string;
+}
+/** A category used to group prediction events. */
+interface PredictionCategory {
+    id: string;
+    name: string;
+    slug: string;
+}
+
+interface HLOutcomeMeta {
+    outcomes: HLOutcome[];
+    questions: HLQuestion[];
+}
+interface HLOutcome {
+    outcome: number;
+    name: string;
+    description: string;
+    sideSpecs: HLSideSpec[];
+}
+interface HLSideSpec {
+    name: string;
+    token?: number;
+}
+interface HLQuestion {
+    question: number;
+    name: string;
+    description: string;
+    fallbackOutcome: number;
+    namedOutcomes: number[];
+    settledNamedOutcomes: number[];
+}
+interface HLSettledOutcome {
+    spec: HLOutcome;
+    settleFraction: string;
+    details: string;
+    /**
+     * Parent question, returned by HL for outcomes that belong to a question
+     * group (priceBucket, multiOutcome). Omitted for standalone priceBinary
+     * outcomes. The `description` here is the parent question's description
+     * (e.g. `class:priceBucket|underlying:BTC|...`), which is what consumers
+     * need to recover bucket bounds after the question itself has been
+     * removed from `outcomeMeta`.
+     */
+    question?: {
+        /** Inner shape mirrors HL's API: `{ settled: <questionId> }`. */
+        question: {
+            settled: number;
+        };
+        name: string;
+        description: string;
+    };
+}
+interface HLL2Book {
+    coin: string;
+    time: number;
+    levels: [HLL2Level[], HLL2Level[]];
+}
+interface HLL2Level {
+    px: string;
+    sz: string;
+    n: number;
+}
+interface HLTrade {
+    coin: string;
+    side: "B" | "A";
+    px: string;
+    sz: string;
+    time: number;
+    hash: string;
+    tid: number;
+    users: [string, string];
+}
+interface HLCandle {
+    t: number;
+    T: number;
+    s: string;
+    i: string;
+    o: string;
+    c: string;
+    h: string;
+    l: string;
+    v: string;
+    n: number;
+}
+type HLAllMids = Record<string, string>;
+interface HLClearinghouseState {
+    marginSummary: {
+        accountValue: string;
+        totalNtlPos: string;
+        totalRawUsd: string;
+        totalMarginUsed: string;
+    };
+    crossMarginSummary: {
+        accountValue: string;
+        totalNtlPos: string;
+        totalRawUsd: string;
+        totalMarginUsed: string;
+    };
+    crossMaintenanceMarginUsed: string;
+    withdrawable: string;
+    assetPositions: HLAssetPosition[];
+    time: number;
+}
+interface HLAssetPosition {
+    type: string;
+    position: {
+        coin: string;
+        szi: string;
+        entryPx: string;
+        positionValue: string;
+        unrealizedPnl: string;
+        returnOnEquity: string;
+        liquidationPx: string | null;
+        marginUsed: string;
+        maxLeverage: number;
+        leverage: {
+            type: string;
+            value: number;
+            rawUsd?: string;
+        };
+        cumFunding: {
+            allTime: string;
+            sinceOpen: string;
+            sinceChange: string;
+        };
+    };
+}
+/** Spot clearinghouse state - HIP-4 prediction balances live here */
+interface HLSpotClearinghouseState {
+    balances: Array<{
+        coin: string;
+        token: number;
+        hold: string;
+        total: string;
+        entryNtl: string;
+    }>;
+}
+/** Frontend-formatted open order */
+interface HLFrontendOrder {
+    coin: string;
+    side: "B" | "A";
+    limitPx: string;
+    sz: string;
+    oid: number;
+    timestamp: number;
+    origSz: string;
+    reduceOnly: boolean;
+    orderType: string;
+    tif: string | null;
+    cloid: string | null;
+    triggerCondition?: string;
+    isTrigger?: boolean;
+    triggerPx?: string;
+    children?: unknown[];
+    isPositionTpsl?: boolean;
+}
+interface HLFill {
+    coin: string;
+    px: string;
+    sz: string;
+    side: "B" | "A";
+    time: number;
+    startPosition: string;
+    dir: string;
+    closedPnl: string;
+    hash: string;
+    oid: number;
+    crossed: boolean;
+    fee: string;
+    tid: number;
+    feeToken: string;
+}
+interface HLWsUserFillsEvent {
+    readonly isSnapshot: boolean;
+    readonly user: string;
+    readonly fills: HLFill[];
+}
+interface HLOrderAction {
+    type: "order";
+    orders: HLOrderWire[];
+    grouping: "na";
+}
+interface HLOrderWire {
+    a: number;
+    b: boolean;
+    p: string;
+    s: string;
+    r: boolean;
+    t: HLOrderType;
+    /** Client order ID (hex string). Optional. */
+    c?: string;
+}
+type HLOrderType = {
+    limit: {
+        tif: "Gtc" | "Ioc" | "Alo" | "FrontendMarket";
+    };
+} | {
+    trigger: {
+        triggerPx: string;
+        isMarket: boolean;
+        tpsl: "tp" | "sl";
+    };
+};
+interface HLSignature {
+    r: string;
+    s: string;
+    v: number;
+}
+interface HLExchangeResponse {
+    status: "ok" | "err";
+    response?: {
+        type: "order";
+        data: {
+            statuses: HLOrderStatus[];
+        };
+    };
+}
+type HLOrderStatus = {
+    filled: {
+        totalSz: string;
+        avgPx: string;
+        oid: number;
+    };
+} | {
+    resting: {
+        oid: number;
+    };
+} | {
+    error: string;
+};
+interface HLSplitOutcomeAction {
+    type: "userOutcome";
+    splitOutcome: {
+        outcome: number;
+        amount: string;
+    };
+}
+interface HLMergeOutcomeAction {
+    type: "userOutcome";
+    mergeOutcome: {
+        outcome: number;
+        amount: string | null;
+    };
+}
+interface HLMergeQuestionAction {
+    type: "userOutcome";
+    mergeQuestion: {
+        question: number;
+        amount: string | null;
+    };
+}
+/**
+ * The on-wire sub-key is `negateOutcome` (matching the page heading), NOT
+ * `negateQuestion` as the docs body's example renders it. Confirmed by
+ * inspecting Hyperliquid's own testnet "Convert Outcomes" UI on 2026-05-07
+ * - its `/exchange` POST sends `{ negateOutcome: { question, outcome,
+ * amount } }`. The docs body is a typo; the heading is correct.
+ */
+interface HLNegateOutcomeAction {
+    type: "userOutcome";
+    negateOutcome: {
+        question: number;
+        outcome: number;
+        amount: string;
+    };
+}
+type HLUserOutcomeAction = HLSplitOutcomeAction | HLMergeOutcomeAction | HLMergeQuestionAction | HLNegateOutcomeAction;
+interface HLScheduleCancelAction {
+    type: "scheduleCancel";
+    /** Unix milliseconds at which HL cancels every open order from this agent. `null` clears. */
+    time: number | null;
+}
+interface HLCancelAction {
+    type: "cancel";
+    cancels: Array<{
+        a: number;
+        o: number;
+    }>;
+}
+type HLCancelStatus = "success" | {
+    error: string;
+};
+interface HLCancelResponse {
+    status: "ok" | "err";
+    response?: {
+        type: "cancel";
+        data: {
+            statuses: HLCancelStatus[];
+        };
+    };
+}
+/**
+ * Modify an existing order. HL preserves queue priority for size-only
+ * changes; price changes move the order to the back of the queue at the
+ * new level. See https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint
+ */
+interface HLModifyAction {
+    type: "modify";
+    oid: number;
+    order: HLOrderWire;
+}
+interface HLBatchModifyAction {
+    type: "batchModify";
+    modifies: Array<{
+        oid: number;
+        order: HLOrderWire;
+    }>;
+}
+/**
+ * HL's modify response. On success, `response` is the structured object
+ * with per-order statuses. On failure (`status: "err"`), HL returns the
+ * error reason as a plain string in `response` - surface it instead of
+ * discarding the payload.
+ */
+interface HLModifyResponse {
+    status: "ok" | "err";
+    response?: {
+        type: "modify" | "batchModify";
+        data: {
+            statuses: HLOrderStatus[];
+        };
+    } | string;
+}
+interface HLWsL2BookData {
+    coin: string;
+    time: number;
+    levels: [
+        Array<{
+            px: string;
+            sz: string;
+            n: number;
+        }>,
+        Array<{
+            px: string;
+            sz: string;
+            n: number;
+        }>
+    ];
+    spread?: string;
+}
+/** BBO (Best Bid and Offer) WebSocket data - sent when the top-of-book changes. */
+interface HLWsBboData {
+    coin: string;
+    time: number;
+    bbo: [HLWsBboLevel | null, HLWsBboLevel | null];
+}
+interface HLWsBboLevel {
+    px: string;
+    sz: string;
+    n: number;
+}
+interface HLWsAllMidsData {
+    mids: Record<string, string>;
+}
+interface HLWsActiveSpotAssetCtxData {
+    coin: string;
+    ctx: {
+        dayNtlVlm: string;
+        markPx: string;
+        midPx: string | null;
+        prevDayPx: string;
+        circulatingSupply: string;
+        coin: string;
+        totalSupply: string;
+        dayBaseVlm: string;
+    };
+}
+/** Single item from the bulk spotAssetCtxs WS subscription (flat, no ctx wrapper). */
+interface HLWsSpotAssetCtxItem {
+    coin: string;
+    dayNtlVlm: string;
+    markPx: string;
+    midPx: string | null;
+    prevDayPx: string;
+    circulatingSupply: string;
+    totalSupply: string;
+    dayBaseVlm: string;
+}
+/** Bulk spot asset context WS response - flat array from spotAssetCtxs subscription. */
+type HLWsSpotAssetCtxsData = HLWsSpotAssetCtxItem[];
+interface HLWsActivePerpAssetCtxData {
+    coin: string;
+    ctx: {
+        markPx: string;
+        oraclePx: string;
+        funding: string;
+        openInterest: string;
+        dayNtlVlm: string;
+        premium: string;
+        prevDayPx: string;
+    };
+}
+type HLWsTradesEvent = HLTrade[];
+interface HLWsOutcomeMetaSideSpec {
+    name: string;
+}
+interface HLWsOutcomeSpec {
+    outcome: number;
+    name: string;
+    description: string;
+    sideSpecs: [HLWsOutcomeMetaSideSpec, HLWsOutcomeMetaSideSpec];
+}
+interface HLWsQuestionSpec {
+    question: number;
+    name: string;
+    description: string;
+    fallbackOutcome: number;
+    namedOutcomes: number[];
+    settledNamedOutcomes: number[];
+}
+type HLWsOutcomeMetaUpdate = {
+    outcomeCreated: HLWsOutcomeSpec;
+} | {
+    outcomeSettled: number;
+} | {
+    questionUpdated: HLWsQuestionSpec;
+} | {
+    questionSettled: number;
+};
+type HLWsOutcomeMetaUpdates = HLWsOutcomeMetaUpdate[];
+interface HLWsSpotStateEvent {
+    user: `0x${string}`;
+    spotState: HLSpotClearinghouseState;
+}
+interface HLWsOpenOrdersEvent {
+    dex: string;
+    user: `0x${string}`;
+    orders: HLFrontendOrder[];
+}
+interface HLWsClearinghouseStateEvent {
+    dex: string;
+    user: `0x${string}`;
+    clearinghouseState: HLClearinghouseState;
+}
+interface HLExtraAgent {
+    address: `0x${string}`;
+    name: string;
+    validUntil: number;
+}
+interface HLUserRoleResponse {
+    /** Role assigned to the address by Hyperliquid (e.g. "user", "subAccount", "missing"). */
+    role?: string;
+}
+/**
+ * Account abstraction mode reported by the `userAbstraction` info endpoint.
+ *
+ * - `default` - standard mode returned by HL for regular accounts. Spot
+ *   and per-perp-DEX wallets are separate. `usdClassTransfer` required.
+ * - `disabled` - legacy name for the same classic Standard mode; treated
+ *   identically to `"default"`. Kept for backwards compatibility.
+ * - `dexAbstraction` - unifies multiple perp DEXes into one balance, but
+ *   the spot/perp split is preserved. `usdClassTransfer` is still
+ *   required and still allowed.
+ * - `unifiedAccount` - spot ↔ perps balances merged into a single balance.
+ *   `usdClassTransfer` is rejected.
+ * - `portfolioMargin` - unified account plus cross-asset portfolio margin.
+ *   `usdClassTransfer` is rejected.
+ *
+ * Only `unifiedAccount` and `portfolioMargin` trigger the API rejection
+ * `"Action disabled when unified account is active"`.
+ */
+type HLUserAbstraction = "default" | "disabled" | "dexAbstraction" | "unifiedAccount" | "portfolioMargin";
+/**
+ * Response shape of Hyperliquid's `userFees` info request.
+ * Rates are decimal strings (e.g. "0.000538" = 0.0538%).
+ *
+ * For HIP-4 outcome markets (spot-style), use `userSpotCrossRate`
+ * (taker) and `userSpotAddRate` (maker) - these already include
+ * tier, referral, staking, and aligned-quote-asset discounts.
+ */
+interface HLUserFees {
+    userCrossRate: string;
+    userAddRate: string;
+    userSpotCrossRate: string;
+    userSpotAddRate: string;
+    activeReferralDiscount?: string;
+    activeStakingDiscount?: {
+        discount: string;
+        bpsOfMaxSupply: string;
+    } | null;
+}
+interface HLReferralState {
+    /** The referrer's address, if set */
+    referredBy?: {
+        code: string;
+        referrer: string;
+    } | null;
+    /** Cumulative referral rewards info */
+    cumVlm?: string;
+    unclaimedRewards?: string;
+    claimedRewards?: string;
+}
+interface HIP4Signer {
+    getAddress(): string | Promise<string>;
+    /**
+     * Sign a typed-data payload (EIP-712).
+     * Can return either:
+     *   - HLSignature ({r, s, v}) directly
+     *   - A hex string "0x..." which will be split into {r, s, v}
+     */
+    signTypedData(domain: Record<string, unknown>, types: Record<string, Array<{
+        name: string;
+        type: string;
+    }>>, value: Record<string, unknown>): Promise<HLSignature | string>;
+}
+/**
+ * Convert a viem hex signature (0x + 32 bytes r + 32 bytes s + 1 byte v)
+ * into the {r, s, v} format HL expects.
+ */
+declare function splitHexSignature(hex: string): HLSignature;
+/**
+ * Normalize a signature that may be hex or already split.
+ */
+declare function normalizeSignature(sig: HLSignature | string): HLSignature;
+
+type MarketType = "defaultBinary" | "labelledBinary" | "multiOutcome" | "priceBucket";
+interface MarketSide {
+    /** Human-readable side name (e.g. "Yes", "No", "Hypurr") */
+    name: string;
+    /** Raw coin number: outcomeId * 10 + sideIndex */
+    coinNum: number;
+    /** Coin string for API calls: "#<coinNum>" */
+    coin: string;
+    /** Order asset field: 100_000_000 + coinNum */
+    asset: number;
+}
+interface BaseMarket {
+    type: MarketType;
+    /** HL outcome ID */
+    outcomeId: number;
+    /** Human-readable name */
+    name: string;
+    /** Human-readable description */
+    description: string;
+    /** Both sides with pre-computed coin/asset identifiers */
+    sides: [MarketSide, MarketSide];
+    /** Raw HL API response  - always attached for escape-hatch access */
+    raw: HLOutcome;
+}
+interface DefaultBinaryMarket extends BaseMarket {
+    type: "defaultBinary";
+    /** Underlying asset symbol (e.g. "BTC", "ETH", "HYPE") */
+    underlying: string;
+    /** Strike price */
+    targetPrice: number;
+    /** Expiry timestamp as Date (UTC) */
+    expiry: Date;
+    /** Period string (e.g. "15m", "1h", "1d") */
+    period: string;
+}
+interface LabelledBinaryMarket extends BaseMarket {
+    type: "labelledBinary";
+}
+interface MultiOutcomeMarket extends BaseMarket {
+    type: "multiOutcome";
+    /** Parent question ID */
+    questionId: number;
+    /** Parent question name */
+    questionName: string;
+    /** Parent question description */
+    questionDescription: string;
+    /** Whether this is the fallback ("Other") outcome */
+    isFallback: boolean;
+    /** Raw question from API */
+    rawQuestion: HLQuestion;
+}
+interface PriceBucketMarket extends BaseMarket {
+    type: "priceBucket";
+    /** Underlying asset symbol (e.g. "BTC") */
+    underlying: string;
+    /** Expiry timestamp as Date (UTC) */
+    expiry: Date;
+    /** Sorted ascending price thresholds. N thresholds → N+1 buckets. */
+    priceThresholds: number[];
+    /** Period string (e.g. "15m", "1h", "1d") */
+    period: string;
+    /** Parent question ID */
+    questionId: number;
+    /** Parent question name */
+    questionName: string;
+    /** Parent question description (the raw priceBucket spec) */
+    questionDescription: string;
+    /** Whether this is the settlement fallback outcome */
+    isFallback: boolean;
+    /**
+     * Index of this bucket within the question's namedOutcomes array.
+     * -1 when this is the fallback outcome.
+     */
+    bucketIndex: number;
+    /** Lower bound of this bucket (inclusive). null = unbounded below. */
+    lowerBound: number | null;
+    /** Upper bound of this bucket (exclusive). null = unbounded above. */
+    upperBound: number | null;
+    /** Raw question from API */
+    rawQuestion: HLQuestion;
+}
+type HIP4Market = DefaultBinaryMarket | LabelledBinaryMarket | MultiOutcomeMarket | PriceBucketMarket;
+interface FetchMarketsParams {
+    /** Filter to a specific market type */
+    type?: MarketType;
+    /** Sort order. Default: "newest" */
+    sortBy?: "volume" | "expiry" | "newest";
+    /** Group results by key */
+    groupBy?: "type" | "question";
+    /** Max results (after filtering). Default: 100 */
+    limit?: number;
+    /** Offset for pagination. Default: 0 */
+    offset?: number;
+}
+/** Result when groupBy is "type" */
+type MarketsByType = Partial<Record<MarketType, HIP4Market[]>>;
+/** Result when groupBy is "question"  - keyed by questionId or "standalone" */
+type MarketsByQuestion = Record<string, HIP4Market[]>;
+/** Return type varies based on groupBy */
+type FetchMarketsResult<T extends FetchMarketsParams> = T extends {
+    groupBy: "type";
+} ? MarketsByType : T extends {
+    groupBy: "question";
+} ? MarketsByQuestion : HIP4Market[];
+
+/** Snapshot of the order book for one side of a prediction market. */
+interface PredictionOrderBook {
+    marketId: string;
+    bids: PredictionOrderBookLevel[];
+    asks: PredictionOrderBookLevel[];
+    timestamp: number;
+}
+/** A single price level in the order book. */
+interface PredictionOrderBookLevel {
+    price: string;
+    size: string;
+}
+/** A filled trade on a prediction market. */
+interface PredictionTrade {
+    id: string;
+    marketId: string;
+    outcome: string;
+    side: "buy" | "sell";
+    price: string;
+    size: string;
+    timestamp: number;
+}
+/** Current price information for both sides of a prediction market. */
+interface PredictionPrice {
+    marketId: string;
+    /** Price data for each side. Names are generic ("Side 0"/"Side 1") - use event.markets[].outcomes[].name for real names. */
+    outcomes: Array<{
+        name: string;
+        price: string;
+        midpoint: string;
+    }>;
+    timestamp: number;
+}
+
+/** Parameters for placing a prediction market order. */
+interface PredictionOrderParams {
+    marketId: string;
+    outcome: string;
+    side: "buy" | "sell";
+    type: "market" | "limit";
+    /** Required for limit orders. */
+    price?: string;
+    amount: string;
+    timeInForce?: "GTC" | "GTD" | "FOK" | "FAK" | "ALO";
+    expiration?: string;
+    /**
+     * Mark price of the coin (0-1), used for minimum notional validation.
+     * When provided, getMinShares(markPx) is enforced before submission.
+     */
+    markPx?: number;
+    /**
+     * Builder address for referral fees.
+     * Will be lowercased  - checksummed addresses are accepted.
+     */
+    builderAddress?: string;
+    /**
+     * Builder fee in tenths of a basis point.
+     * 0 = no fee. 100 = 0.1%. 1000 = 1.0% (maximum).
+     */
+    builderFee?: number;
+    /**
+     * When true, skips the SDK's local minimum-notional and minimum-shares
+     * pre-checks. Use for position-closing flows (close, close-all) where
+     * the residual notional may be under $10 but Hyperliquid still accepts
+     * the order.
+     */
+    skipMinNotionalCheck?: boolean;
+}
+/** Result returned by placeOrder. Never throws. Check success/error fields. */
+interface PredictionOrderResult {
+    success: boolean;
+    orderId?: string;
+    status?: string;
+    shares?: string;
+    error?: string;
+}
+/** Result returned by placeOrders (batch). One entry per input order, index-matched. */
+interface PredictionBatchOrderResult {
+    /** True when every individual order succeeded. */
+    success: boolean;
+    /** Per-order results, indexed to match the input params array. */
+    results: PredictionOrderResult[];
+}
+/** Parameters for cancelling a resting order. */
+interface PredictionCancelParams {
+    marketId: string;
+    orderId: string;
+    /** Optional outcome identifier (e.g. "#5160") to resolve the correct side asset ID. */
+    outcome?: string;
+}
+/**
+ * Parameters for modifying an existing resting order. Hyperliquid preserves
+ * queue priority when only the size is changed; price changes move the order
+ * to the back of the queue at the new level.
+ *
+ * Note: HL's modify endpoint only accepts resting limit orders (market orders
+ * never rest). `type` is locked to "limit" accordingly.
+ */
+interface PredictionModifyParams {
+    marketId: string;
+    outcome: string;
+    orderId: string;
+    side: "buy" | "sell";
+    type: "limit";
+    price: string;
+    amount: string;
+    timeInForce?: "GTC" | "GTD" | "FOK" | "FAK" | "ALO";
+    markPx?: number;
+}
+
+export { type HLWsTradesEvent as $, type HLSignature as A, type BaseMarket as B, type HLSplitOutcomeAction as C, type DefaultBinaryMarket as D, type HLSpotClearinghouseState as E, type FetchMarketsParams as F, type HLTrade as G, type HIP4Market as H, type HLUserAbstraction as I, type HLUserFees as J, type HLUserOutcomeAction as K, type HLUserRoleResponse as L, type HLWsActivePerpAssetCtxData as M, type HLWsActiveSpotAssetCtxData as N, type HLWsAllMidsData as O, type HLWsBboData as P, type HLWsClearinghouseStateEvent as Q, type HLWsL2BookData as R, type HLWsOpenOrdersEvent as S, type HLWsOutcomeMetaSideSpec as T, type HLWsOutcomeMetaUpdate as U, type HLWsOutcomeMetaUpdates as V, type HLWsOutcomeSpec as W, type HLWsQuestionSpec as X, type HLWsSpotAssetCtxItem as Y, type HLWsSpotAssetCtxsData as Z, type HLWsSpotStateEvent as _, type FetchMarketsResult as a, type HLWsUserFillsEvent as a0, type LabelledBinaryMarket as a1, type MarketSide as a2, type MarketType as a3, type MarketsByQuestion as a4, type MarketsByType as a5, type MultiOutcomeMarket as a6, type PredictionActivity as a7, type PredictionAuthState as a8, type PredictionBatchOrderResult as a9, type PredictionCancelParams as aa, type PredictionCategory as ab, type PredictionEvent as ac, type PredictionEventStatus as ad, type PredictionMarket as ae, type PredictionModifyParams as af, type PredictionOrderBook as ag, type PredictionOrderBookLevel as ah, type PredictionOrderParams as ai, type PredictionOrderResult as aj, type PredictionOutcome as ak, type PredictionPosition as al, type PredictionPrice as am, type PredictionTrade as an, type PriceBucketMarket as ao, normalizeSignature as ap, splitHexSignature as aq, type HIP4Signer as b, type HLAllMids as c, type HLBatchModifyAction as d, type HLCancelAction as e, type HLCancelResponse as f, type HLCancelStatus as g, type HLCandle as h, type HLClearinghouseState as i, type HLExchangeResponse as j, type HLExtraAgent as k, type HLFill as l, type HLFrontendOrder as m, type HLL2Book as n, type HLMergeOutcomeAction as o, type HLMergeQuestionAction as p, type HLModifyAction as q, type HLModifyResponse as r, type HLNegateOutcomeAction as s, type HLOrderAction as t, type HLOutcome as u, type HLOutcomeMeta as v, type HLQuestion as w, type HLReferralState as x, type HLScheduleCancelAction as y, type HLSettledOutcome as z };