@domfi/sdk 0.1.0

package/dist/types-7s13ZSql.d.ts

@@ -0,0 +1,533 @@
+import { DiagnosticsEnvelope } from './errors.js';
+import { Address, PairIndex, TradeIndex, TradeId, TriggerOrderIndex, OrderId, Hex, IsoTimestamp, Collateral, Price, Leverage, Notional, DecimalString, SignedCollateral, SignedP18, ClosePercent, TimeInput, WholePercent, FeePercent, Precision2Percent, Ratio, UnsignedP18, ScaleP2, SignedP6, UsdP6 } from './units.js';
+
+/** Position identity verified by API data, valuation snapshots, or caller-provided trade IDs. */
+type VerifiedPositionRef = {
+    wallet: Address;
+    pairIndex: PairIndex;
+    index: TradeIndex;
+    tradeId: TradeId;
+    chainId: number;
+    source: "api" | "snapshot" | "caller";
+};
+/** Open limit/stop order identity verified from API read models. */
+type ApiVerifiedOpenTriggerOrderRef = {
+    wallet: Address;
+    pairIndex: PairIndex;
+    index: TriggerOrderIndex;
+    chainId: number;
+    lifecycleKey: string;
+    orderId?: OrderId;
+    orderType: "limit" | "stop";
+    initiatedTxHash: Hex;
+    initiatedEventType: string;
+    initiatedLog?: {
+        blockNumber: bigint;
+        transactionIndex: number;
+        logIndex: number;
+    };
+    source: "api";
+};
+/** Open limit/stop order identity recovered directly from a placement transaction receipt. */
+type ReceiptVerifiedOpenTriggerOrderRef = {
+    wallet: Address;
+    pairIndex: PairIndex;
+    index: TriggerOrderIndex;
+    chainId: number;
+    lifecycleKey?: string;
+    orderId?: OrderId;
+    orderType: "limit" | "stop";
+    initiatedTxHash: Hex;
+    initiatedLog: {
+        blockNumber: bigint;
+        transactionIndex: number;
+        logIndex: number;
+    };
+    source: "receipt";
+};
+/** Verified open trigger order identity accepted by trigger update/cancel helpers. */
+type VerifiedOpenTriggerOrderRef = ApiVerifiedOpenTriggerOrderRef | ReceiptVerifiedOpenTriggerOrderRef;
+/** Alias for verified trigger order identities. */
+type VerifiedTriggerOrderRef = VerifiedOpenTriggerOrderRef;
+/** Unverified trigger order slot for display or low-level recovery flows. */
+type UnsafeTriggerOrderSlot = {
+    wallet: Address;
+    pairIndex: PairIndex;
+    index: TriggerOrderIndex;
+};
+/** Input accepted by `verifiedPositionRef` for caller-known position identities. */
+type VerifiedPositionRefInput = {
+    wallet: Address;
+    pairIndex: PairIndex;
+    index: TradeIndex;
+    tradeId: TradeId;
+    chainId: number;
+};
+/** Options for parsing trigger placement identities from transaction receipts. */
+type TriggerReceiptParseOptions = {
+    chainId: number;
+    expectedWallet?: Address;
+    expectedOrderType?: "limit" | "stop";
+};
+/** Brands caller-known position identity as a verified position reference. */
+declare function verifiedPositionRef(input: VerifiedPositionRefInput): VerifiedPositionRef;
+
+/** Common controls for SDK REST reads and RPC-backed reads. */
+type ReadOptions = {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+    /** Controls how REST freshness/readiness metadata is enforced. Defaults vary by client. */
+    readinessPolicy?: "strict" | "warn" | "ignore";
+};
+/** Cursor pagination controls for REST list endpoints. */
+type PageOptions = ReadOptions & {
+    cursor?: string;
+    limit?: number;
+};
+/** Pagination controls for vault history endpoints. */
+type VaultHistoryPageOptions = PageOptions;
+/** Read-model freshness metadata returned with mapped REST responses. */
+type Freshness = {
+    source: string;
+    generatedAt: IsoTimestamp;
+    indexedBlock?: bigint;
+    chainHeadBlock?: bigint;
+    lagBlocks?: bigint;
+    cacheStatus?: string;
+    cacheAgeSeconds?: bigint;
+    isStale: boolean;
+};
+/** Standard mapped REST response envelope. */
+type ResultEnvelope<T> = {
+    data: T;
+    freshness: Freshness;
+    diagnostics?: DiagnosticsEnvelope;
+};
+/** Cursor pagination metadata returned by REST list endpoints. */
+type CursorPagination = {
+    cursor?: string;
+    nextCursor?: string;
+    hasNext: boolean;
+    limit: number;
+};
+/** Paginated REST response envelope. */
+type Page<T> = ResultEnvelope<T[]> & {
+    pagination: CursorPagination;
+};
+/** Single item yielded by SDK page iterators, including its page metadata. */
+type PageItem<T> = {
+    item: T;
+    freshness: Freshness;
+    pagination: CursorPagination;
+    diagnostics?: DiagnosticsEnvelope;
+};
+/** Paginated trade event response grouped under a trade id. */
+type TradeEventsPage = ResultEnvelope<{
+    tradeId: TradeId;
+    events: TradeEvent[];
+}> & {
+    pagination: CursorPagination;
+};
+/** Normalized market availability status. */
+type MarketStatus = "active" | "paused" | "done" | "unknown";
+/** Normalized position side. */
+type PositionSide = "long" | "short";
+/** Normalized order lifecycle status. */
+type OrderStatus = "pending_execution" | "timeout_available" | "executed" | "canceled" | "timed_out" | "unknown";
+/** Normalized order action. */
+type OrderAction = "open" | "close" | "remove_collateral" | "unknown";
+/** Normalized order type. */
+type OrderType = "market" | "limit" | "stop" | "automation" | "remove_collateral" | "unknown";
+/** Raw protocol market state exposed for parity/debugging use cases. */
+type MarketRawState = {
+    accPerOiLong: SignedP18;
+    accPerOiShort: SignedP18;
+    lastFundingRate: SignedP18;
+    maxFundingFeePerBlock: UnsignedP18;
+    springFactor: UnsignedP18;
+    hillInflectionPoint: SignedP18;
+    hillPosScale: ScaleP2;
+    hillNegScale: ScaleP2;
+    sFactorUpScaleP: ScaleP2;
+    sFactorDownScaleP: ScaleP2;
+    lastOiDelta: SignedP6;
+    lastUpdateBlock: bigint;
+    asOfBlock: bigint;
+    lastTradePrice: Price;
+    oiLong: UnsignedP18;
+    oiShort: UnsignedP18;
+    oiCap: UsdP6;
+    groupCollateralLong?: Collateral;
+    groupCollateralShort?: Collateral;
+};
+/** Market-level trading limits used by preflight and math helpers. */
+type MarketConstraints = {
+    minLeverage: Leverage;
+    maxLeverage: Leverage;
+    makerMaxLeverage: Leverage;
+    minLevPosition: Collateral;
+    groupMaxCollateral: Collateral;
+    maxAllowedCollateral?: Collateral;
+    maxNegativePnlOnOpenP?: WholePercent;
+    maxSlP?: WholePercent;
+    liqMarginThresholdP?: WholePercent;
+    marketOrdersTimeout: bigint;
+    maxTradesPerPair: bigint;
+    maxPendingMarketOrders: bigint;
+};
+/** Opening or closing fee schedule for a market. */
+type MarketFeeSchedule = {
+    makerFeeP: FeePercent;
+    takerFeeP: FeePercent;
+    usageFeeP: FeePercent;
+    utilizationThresholdP: Precision2Percent;
+    makerMaxLeverage: Leverage;
+    vaultFeePercent: WholePercent;
+};
+/** Contract addresses backing a market. */
+type MarketContracts = {
+    trading: Address;
+    tradingStorage: Address;
+    pairsStorage: Address;
+    pairInfos: Address;
+};
+/** Static market metadata plus current constraints and fee schedules. */
+type Market = {
+    pairIndex: PairIndex;
+    groupIndex: number;
+    feeIndex: number;
+    symbol: string;
+    baseSymbol: string;
+    quoteSymbol: string;
+    priceAsset: string;
+    feedId: Hex;
+    priceFeed: string;
+    isListed: boolean;
+    isPaused: boolean;
+    isDone: boolean;
+    status: MarketStatus;
+    rawStatus?: string;
+    oracleFeeWei: bigint;
+    contracts: MarketContracts;
+    constraints: MarketConstraints;
+    fees: {
+        opening: MarketFeeSchedule;
+        closing: MarketFeeSchedule;
+    };
+};
+/** Dynamic market state such as open interest, funding, and volume. */
+type MarketState = {
+    pairIndex: PairIndex;
+    longOpenInterest: Notional;
+    shortOpenInterest: Notional;
+    oiMax: Notional;
+    oiDelta: Ratio;
+    lastFunding1h: Ratio;
+    lastFunding8h: Ratio;
+    lastFunding24h: Ratio;
+    lastFunding1y: Ratio;
+    fundingFeeLong: Ratio;
+    fundingFeeShort: Ratio;
+    fundingFeeRate: Ratio;
+    fundingRate1h: Ratio;
+    fundingRate8h: Ratio;
+    fundingRate24h: Ratio;
+    fundingRate1y: Ratio;
+    cumulativeVolume: Notional;
+    volume24h: Notional;
+    rawState?: MarketRawState;
+};
+/** Latest known price for an asset/product. */
+type PriceHead = {
+    asset: string;
+    productId: string;
+    price: Price;
+    timestamp: IsoTimestamp;
+};
+/** Price query selector by asset name, pair index, or both. */
+type PriceSelector = {
+    asset: string;
+    pairIndex?: PairIndex;
+} | {
+    pairIndex: PairIndex;
+    asset?: string;
+};
+/** Candle query parameters. */
+type CandleParams = PriceSelector & {
+    interval: string;
+    from: TimeInput;
+    to?: TimeInput;
+};
+/** OHLC candle returned by the REST price API. */
+type Candle = {
+    pairIndex?: PairIndex;
+    asset: string;
+    open: Price;
+    high: Price;
+    low: Price;
+    close?: Price;
+    headPrice?: Price;
+    headTime?: IsoTimestamp;
+    openTime: IsoTimestamp;
+    closeTime?: IsoTimestamp;
+};
+/** Tick query parameters. */
+type PriceTickParams = PriceSelector & {
+    from?: TimeInput;
+    to?: TimeInput;
+};
+/** Price tick returned by the REST price API. */
+type PriceTick = {
+    pairIndex?: PairIndex;
+    asset: string;
+    productId: string;
+    price: Price;
+    publishId?: string;
+    blockNumber: bigint;
+    txIndex: bigint;
+    logIndex: bigint;
+    timestamp: IsoTimestamp;
+};
+/** Reason an account position is pending or not directly actionable. */
+type PendingPositionReason = "being_market_closed" | "remove_collateral_pending" | "trigger_pending" | "read_model_not_ready" | "unknown_pending_mutation";
+/** Account position that is currently open and has a concrete trade slot. */
+type OpenAccountPosition = {
+    kind: "open_position";
+    rawKind?: string;
+    wallet: Address;
+    pairIndex: PairIndex;
+    index: TradeIndex;
+    tradeId: TradeId;
+    side: PositionSide;
+    collateral: Collateral;
+    initialCollateral?: Collateral;
+    initialAccFundingRaw?: SignedP18;
+    leverage: Leverage;
+    notional?: Notional;
+    openPrice: Price;
+    takeProfit?: Price;
+    stopLoss?: Price;
+    openedAt?: IsoTimestamp;
+    pendingReasons: PendingPositionReason[];
+    verifiedRef?: VerifiedPositionRef;
+};
+/** Account position-like mutation that has not settled into an open position yet. */
+type PendingAccountPosition = {
+    kind: "pending_position";
+    rawKind: string;
+    wallet: Address;
+    orderId?: OrderId;
+    eventType: string;
+    pairIndex?: PairIndex;
+    index?: TradeIndex;
+    tradeId?: TradeId;
+    side?: PositionSide;
+    collateral?: Collateral;
+    initialCollateral?: Collateral;
+    leverage?: Leverage;
+    notional?: Notional;
+    openPrice?: Price;
+    wantedPrice?: Price;
+    takeProfit?: Price;
+    stopLoss?: Price;
+    targetTradeId?: TradeId;
+    closePercentage?: ClosePercent;
+    removeAmount?: Collateral;
+    limitIndex?: TriggerOrderIndex;
+    txHash?: Hex;
+    timestamp?: IsoTimestamp;
+    pendingReasons: PendingPositionReason[];
+};
+/** Account position view containing both open and pending entries. */
+type AccountPosition = OpenAccountPosition | PendingAccountPosition;
+/** Fully identified position reference returned by account read models. */
+type PositionRef = {
+    wallet: Address;
+    pairIndex: PairIndex;
+    index: TradeIndex;
+    tradeId: TradeId;
+};
+/** Lookup reference for resolving a single account position. */
+type AccountPositionLookupRef = {
+    pairIndex: PairIndex;
+    index: TradeIndex;
+    tradeId?: TradeId;
+};
+/** Fully resolved account position lookup reference. */
+type AccountPositionResolvedRef = {
+    pairIndex: PairIndex;
+    index: TradeIndex;
+    tradeId: TradeId;
+};
+/** Batch lookup reference; currently requires fully resolved trade identity. */
+type AccountPositionBatchLookupRef = AccountPositionResolvedRef;
+/** Result status for an account position lookup. */
+type AccountPositionLookupStatus = "found" | "missing" | "pending";
+/** Result of resolving an account position reference against read models. */
+type AccountPositionLookupResult = {
+    ref: AccountPositionResolvedRef;
+    status: AccountPositionLookupStatus;
+    position?: AccountPosition;
+    pendingReasons: PendingPositionReason[];
+};
+/** Account order lifecycle summary from read models. */
+type AccountOrder = {
+    orderId: OrderId;
+    lifecycleKey: string;
+    wallet: Address;
+    pairIndex?: PairIndex;
+    action: OrderAction;
+    rawAction?: string;
+    orderType: OrderType;
+    rawOrderType?: string;
+    triggerOrderType?: "limit" | "stop";
+    rawTriggerOrderType?: string;
+    status: OrderStatus;
+    rawStatus?: string;
+    isPending: boolean;
+    isCancelled: boolean;
+    timeoutAvailable?: boolean;
+    timeoutBlock?: bigint;
+    tradeId?: TradeId;
+    positionRef: PositionRef | null;
+    limitIndex?: TriggerOrderIndex;
+    initiatedBlock?: bigint;
+    executedBlock?: bigint;
+    initiatedEventType?: string;
+    terminalEventType?: string;
+    latestEventType?: string;
+    initiatedTxHash?: Hex;
+    executedTxHash?: Hex;
+    cancelReason?: number;
+    timestamp: IsoTimestamp;
+    verifiedRef?: VerifiedOpenTriggerOrderRef;
+};
+/** Open limit/stop order narrowed to the fields needed for trigger updates/cancels. */
+type OpenTriggerAccountOrder = AccountOrder & {
+    lifecycleKey: string;
+    pairIndex: PairIndex;
+    action: "open";
+    orderType: "limit";
+    triggerOrderType: "limit" | "stop";
+    status: "pending_execution";
+    isPending: true;
+    limitIndex: TriggerOrderIndex;
+    initiatedEventType: string;
+    initiatedTxHash: Hex;
+};
+/** Historical or current account trade entry. */
+type AccountTrade = {
+    wallet: Address;
+    pairIndex: PairIndex;
+    index: TradeIndex;
+    tradeId: TradeId;
+    side: PositionSide;
+    openPrice: Price;
+    closePrice?: Price;
+    initialCollateral: Collateral;
+    collateral: Collateral;
+    closingCollateral?: Collateral;
+    leverage: Leverage;
+    notional: Notional;
+    openEventType: string;
+    closeReason?: string;
+    percentProfit?: DecimalString;
+    realizedPnl?: SignedCollateral;
+    collateralSentToTrader?: Collateral;
+    fundingFee?: SignedCollateral;
+    status: string;
+    limitIndex?: TriggerOrderIndex;
+    openTxHash?: Hex;
+    closeTxHash?: Hex;
+    openedAt: IsoTimestamp;
+    closedAt?: IsoTimestamp;
+    timestamp: IsoTimestamp;
+};
+/** Additional state used to reconcile remove-collateral order execution. */
+type RemoveCollateralTracking = {
+    requestedCollateral?: Collateral;
+    executedCollateral?: Collateral;
+    adjustedAmountSource: "order_response" | "receipt_event" | "timeline_event" | "unavailable";
+};
+/** Full lifecycle view of a tracked order. */
+type OrderLifecycle = {
+    orderId: OrderId;
+    wallet: Address;
+    pairIndex?: PairIndex;
+    action: OrderAction;
+    rawAction?: string;
+    orderType: OrderType;
+    rawOrderType?: string;
+    status: OrderStatus;
+    rawStatus?: string;
+    isPending: boolean;
+    isCancelled: boolean;
+    timeoutAvailable: boolean;
+    timeoutBlock?: bigint;
+    tradeId?: TradeId;
+    initiatedTradeId?: TradeId;
+    terminalTradeId?: TradeId;
+    positionRef: PositionRef | null;
+    initiatedEventType?: string;
+    terminalEventType?: string;
+    latestEventType?: string;
+    limitIndex?: TriggerOrderIndex;
+    initiatedTxHash?: Hex;
+    executedTxHash?: Hex;
+    initiatedBlock?: bigint;
+    executedBlock?: bigint;
+    initiatedTxIndex?: bigint;
+    initiatedLogIndex?: bigint;
+    executedTxIndex?: bigint;
+    executedLogIndex?: bigint;
+    timestamp: IsoTimestamp;
+    cancelReason?: number;
+    removeCollateral?: RemoveCollateralTracking;
+};
+/** Timeline event for a trade. */
+type TradeEvent = {
+    id: bigint;
+    tradeId: TradeId;
+    time: IsoTimestamp;
+    eventType: string;
+    blockNumber: bigint;
+    txIndex: bigint;
+    logIndex: bigint;
+    txHash?: Hex;
+    orderId?: OrderId;
+    collateral?: Collateral;
+    leverage?: Leverage;
+    openPrice?: Price;
+    closePrice?: Price;
+    takeProfit?: Price;
+    stopLoss?: Price;
+    percentageClosed?: ClosePercent;
+    percentProfit?: DecimalString;
+    collateralSentToTrader?: Collateral;
+    pnlDelta?: SignedCollateral;
+    topUpAmount?: Collateral;
+    removeAmount?: Collateral;
+    newLeverage?: Leverage;
+    wantedPrice?: Price;
+    cancelReason?: number;
+};
+/** Machine-readable reason the REST API is degraded or not fully ready. */
+type ApiDegradedReason = "rpc_unavailable" | "postgres_unavailable" | "indexer_lagging" | "lag_above_threshold" | "chain_head_behind_indexed_block" | "read_models_not_ready" | "market_metadata_not_ready" | "market_state_not_ready" | string;
+/** REST API health and readiness status. */
+type ApiStatus = {
+    network: string;
+    apiTime: IsoTimestamp;
+    chainHeadBlock?: bigint;
+    indexedBlock?: bigint;
+    lagBlocks?: bigint;
+    rpcAvailable: boolean;
+    postgresAvailable: boolean;
+    cacheAvailable: boolean;
+    degraded: boolean;
+    degradedReasons: ApiDegradedReason[];
+    apiSchemaHash: string;
+    ok: boolean;
+    readiness: Record<string, "ready" | "not_ready" | "degraded">;
+};
+
+export { type AccountOrder as A, type TradeEventsPage as B, type CursorPagination as C, type TradeEvent as D, type AccountPositionLookupStatus as E, type Freshness as F, type AccountPositionResolvedRef as G, type ApiDegradedReason as H, type MarketConstraints as I, type MarketContracts as J, type MarketFeeSchedule as K, type MarketRawState as L, type Market as M, type MarketStatus as N, type OpenAccountPosition as O, type PendingPositionReason as P, type OrderAction as Q, type ReadOptions as R, type OrderStatus as S, type TriggerReceiptParseOptions as T, type UnsafeTriggerOrderSlot as U, type VerifiedPositionRef as V, type OrderType as W, type PendingAccountPosition as X, type PositionRef as Y, type PositionSide as Z, type PriceSelector as _, type ReceiptVerifiedOpenTriggerOrderRef as a, type VerifiedOpenTriggerOrderRef as b, type OpenTriggerAccountOrder as c, type ApiVerifiedOpenTriggerOrderRef as d, type ResultEnvelope as e, type VaultHistoryPageOptions as f, type ApiStatus as g, type AccountPosition as h, type VerifiedPositionRefInput as i, type VerifiedTriggerOrderRef as j, type OrderLifecycle as k, type RemoveCollateralTracking as l, type AccountTrade as m, type MarketState as n, type PriceHead as o, type CandleParams as p, type Candle as q, type PriceTickParams as r, type PageOptions as s, type Page as t, type PriceTick as u, verifiedPositionRef as v, type PageItem as w, type AccountPositionLookupRef as x, type AccountPositionLookupResult as y, type AccountPositionBatchLookupRef as z };

package/dist/types-BK6dYOXr.d.cts

@@ -0,0 +1,118 @@
+import { V as VerifiedPositionRef, R as ReadOptions, P as PendingPositionReason, F as Freshness } from './types-DQft82W7.cjs';
+import { DiagnosticsEnvelope, DomfiError } from './errors.cjs';
+import { Collateral, Leverage, Price, SignedCollateral, IsoTimestamp, Address, PairIndex, TradeIndex } from './units.cjs';
+
+/** Position slot without a verified trade id, useful for display-only fallback reads. */
+type UnverifiedPositionSlot = {
+    wallet: Address;
+    pairIndex: PairIndex;
+    index: TradeIndex;
+};
+/** Source used for the mark price in a valuation snapshot. */
+type MarkSource = "onchain_oracle" | "rest_fallback" | "unavailable";
+/** Preferred mark price source for valuation reads. */
+type MarkSourcePreference = Exclude<MarkSource, "unavailable"> | "auto";
+/** Freshness metadata for valuation snapshots. */
+type SnapshotFreshness = {
+    valuationBlock?: bigint;
+    valuationBlockTimestamp?: IsoTimestamp;
+    markTimestampMs?: bigint;
+    oracleTimestampMs?: bigint;
+    apiFreshness?: Freshness;
+    markApiFreshness?: Freshness;
+    markSource: MarkSource;
+    isStale: boolean;
+};
+/** Current valuation view for a verified position or unverified slot. */
+type PositionSnapshot = {
+    status: "live";
+    position: VerifiedPositionRef;
+    collateral: Collateral;
+    leverage: Leverage;
+    liquidationPrice?: Price;
+    fundingFee: SignedCollateral;
+    markPrice: Price;
+    markSource: MarkSource;
+    markValue: Collateral;
+    unrealizedPnl: SignedCollateral;
+    actionability: "actionable" | "pending_mutation" | "read_only";
+    pendingReasons: PendingPositionReason[];
+    freshness: SnapshotFreshness;
+} | {
+    status: "closed_or_stale";
+    position: VerifiedPositionRef;
+    reason: "gone" | "tradeId_mismatch" | "being_closed" | "pending_mutation" | "read_model_not_ready";
+} | {
+    status: "unverified_slot";
+    slot: UnverifiedPositionSlot;
+    displayOnly: true;
+    markSource: MarkSource;
+    freshness: SnapshotFreshness;
+};
+/** Snapshot variant returned for an unverified position slot. */
+type UnverifiedSlotSnapshot = Extract<PositionSnapshot, {
+    status: "unverified_slot";
+}>;
+/** Snapshot variants returned for verified position references. */
+type VerifiedPositionSnapshot = Exclude<PositionSnapshot, UnverifiedSlotSnapshot>;
+/** Options for single valuation reads. */
+type SnapshotOptions = ReadOptions & {
+    blockTag?: bigint | "latest";
+    markSource?: MarkSourcePreference;
+};
+/** Options for batched valuation reads. */
+type BulkSnapshotOptions = SnapshotOptions & {
+    chunkSize?: number;
+};
+/** Options for valuation watch loops. */
+type WatchSnapshotOptions = SnapshotOptions & {
+    intervalMs?: number;
+    emitImmediately?: boolean;
+};
+/** Event emitted to valuation watch callbacks. */
+type WatchEvent<T> = {
+    type: "snapshot";
+    data: T;
+    diagnostics?: DiagnosticsEnvelope;
+} | {
+    type: "error";
+    error: DomfiError;
+    diagnostics?: DiagnosticsEnvelope;
+};
+/** Callback invoked for valuation watch snapshots and recoverable errors. */
+type WatchCallback<T> = (event: WatchEvent<T>) => void;
+/** Handle returned by valuation watch methods. */
+type WatchHandle = {
+    stop(): void;
+};
+/** Valuation client with REST-assisted verified position reads. */
+type ValuationClient = {
+    /** Clears cached market/config data used by valuation reads. */
+    clearConfigCache(): void;
+    /**
+     * @throws ReadModelNotReadyError when API discovery read models are not ready.
+     * @throws ValidationError when position refs, REST payloads, or onchain reads fail validation.
+     * @throws TimeoutError or AbortError when REST/RPC reads are timed out or aborted.
+     * @throws ApiError, TransportError, or MissingPublicClientError for dependency and transport failures.
+     */
+    positionSnapshot(position: VerifiedPositionRef, opts?: SnapshotOptions): Promise<VerifiedPositionSnapshot>;
+    /** @throws ValidationError, TimeoutError, AbortError, TransportError, or MissingPublicClientError. */
+    unverifiedSlotSnapshot(slot: UnverifiedPositionSlot, opts?: SnapshotOptions): Promise<UnverifiedSlotSnapshot>;
+    /** @throws ReadModelNotReadyError, ValidationError, TimeoutError, AbortError, ApiError, TransportError, or MissingPublicClientError. */
+    positionSnapshots(positions: VerifiedPositionRef[], opts?: BulkSnapshotOptions): Promise<VerifiedPositionSnapshot[]>;
+    /** @throws ValidationError when watch options or callback arguments are invalid. Runtime read failures are emitted as error events. */
+    watchPositionSnapshot(position: VerifiedPositionRef, cb: WatchCallback<VerifiedPositionSnapshot>): WatchHandle;
+    watchPositionSnapshot(position: VerifiedPositionRef, opts: WatchSnapshotOptions, cb: WatchCallback<VerifiedPositionSnapshot>): WatchHandle;
+    /** @throws ValidationError when watch options or callback arguments are invalid. Runtime read failures are emitted as error events. */
+    watchPositionSnapshots(positions: VerifiedPositionRef[], cb: WatchCallback<VerifiedPositionSnapshot[]>): WatchHandle;
+    watchPositionSnapshots(positions: VerifiedPositionRef[], opts: WatchSnapshotOptions, cb: WatchCallback<VerifiedPositionSnapshot[]>): WatchHandle;
+};
+/** Valuation client available when REST API access is disabled. */
+type ValuationClientNoApi = {
+    /** Clears cached market/config data used by valuation reads. */
+    clearConfigCache(): void;
+    /** @throws ValidationError, TimeoutError, AbortError, TransportError, or MissingPublicClientError. */
+    unverifiedSlotSnapshot(slot: UnverifiedPositionSlot, opts?: SnapshotOptions): Promise<UnverifiedSlotSnapshot>;
+};
+
+export type { BulkSnapshotOptions as B, MarkSource as M, PositionSnapshot as P, SnapshotFreshness as S, UnverifiedPositionSlot as U, ValuationClient as V, WatchCallback as W, MarkSourcePreference as a, SnapshotOptions as b, UnverifiedSlotSnapshot as c, ValuationClientNoApi as d, VerifiedPositionSnapshot as e, WatchEvent as f, WatchHandle as g, WatchSnapshotOptions as h };