import type { MulticallRetryFunction } from '../../types';
import type { GmxExecutionFees } from './types';
export interface TickerPrice {
    min: bigint;
    max: bigint;
}
export type TickerPrices = Map<string, TickerPrice>;
/**
 * Fetch the GMX oracle min/max prices from `/prices/tickers`. These are in
 * exactly the fixed-point form `getMarketTokenPrice` / `getGlvTokenPrice`
 * expect, so they can be fed straight in. Keyed by lowercased token address.
 */
export declare const fetchGmxTickerPrices: (chainId: string, apiUrlOverride?: string) => Promise<TickerPrices>;
export interface GmxUsdValue {
    priceUsd: number;
    tvlUsd: number;
    /** Max withdrawable USD — what a holder of the whole vault could pull out
     *  now: pool value minus the part reserved to back open trader positions,
     *  capped at {@link tvlUsd}. The withdrawal-side liquidity. Absent when the
     *  reserve reads failed; see {@link priceGmMarkets}. */
    liquidityUsd?: number;
    /** Remaining deposit capacity in USD — how much more liquidity the market
     *  can accept before hitting GMX's pool caps. Absent when the cap reads
     *  failed or no cap is configured; see {@link priceGmMarkets}. */
    depositCapacityUsd?: number;
}
interface GmMarketInput {
    marketToken: string;
    indexToken: string;
    longToken: string;
    shortToken: string;
}
/**
 * Value GM market tokens in USD via `Reader.getMarketTokenPrice`, fed the
 * index/long/short oracle prices from `/prices/tickers`. Markets missing an
 * oracle price are skipped. Returns a map (lowercased GM token → value).
 * Resolves to an empty map on any failure — pricing is best-effort.
 */
export declare const priceGmMarkets: (chainId: string, multicallRetry: MulticallRetryFunction, markets: GmMarketInput[], prices: TickerPrices) => Promise<Map<string, GmxUsdValue>>;
/**
 * Value GLV tokens in USD. Two stages: `getGlvInfo` (each GLV → its
 * constituent GM markets), then `getGlvTokenPrice` with the per-market
 * index-price array assembled from `/prices/tickers`. Returns the value map,
 * the largest GLV market count (used to size the GLV execution-fee gas
 * estimate), and each GLV's constituent GM markets (lowercased) so callers
 * can approximate GLV withdrawable liquidity from the per-market figures.
 * Best-effort — empty on failure.
 */
export declare const priceGlvVaults: (chainId: string, multicallRetry: MulticallRetryFunction, glvTokens: string[], prices: TickerPrices, 
/** market address (lowercased) → its index token address. From `/markets`. */
marketIndexToken: Map<string, string>) => Promise<{
    values: Map<string, GmxUsdValue>;
    maxMarketCount: number;
    /** GLV address (lowercased) → its constituent GM markets (lowercased). */
    glvMarkets: Map<string, string[]>;
    /** GLV address (lowercased) → its per-market balance caps + current holding,
     *  for the GLV deposit-capacity approximation. */
    glvCaps: Map<string, GlvMarketCap[]>;
}>;
/** Per-(glv, market) GLV deposit-cap state. Balances/amounts in GM-token
 *  native units (18-dec); `maxBalUsd` in GMX 1e30 USD. A `0n` cap means that
 *  cap is not enforced. */
export interface GlvMarketCap {
    /** GM market token address, lowercased. */
    market: string;
    maxBalUsd: bigint;
    maxBalAmount: bigint;
    /** GLV's current GM-token holding for this market. */
    balanceAmount: bigint;
}
/**
 * Estimate per-chain minimum execution fees for the four GM/GLV request
 * types. Reads the DataStore gas-limit + multiplier config in one multicall
 * and multiplies by `gasPriceWei`. Returns `undefined` if the chain is
 * unsupported or the reads/gas-price fail.
 */
export declare const fetchGmxExecutionFees: (chainId: string, multicallRetry: MulticallRetryFunction, gasPriceWei: bigint) => Promise<GmxExecutionFees | undefined>;
export {};
//# sourceMappingURL=pricing.d.ts.map