import { MulticallRetryFunction } from '../types';
import { GenericTokenList } from '../types/general';
import type { FluidFTokens } from './fluid/types';
import type { GearboxV3Pools } from './gearbox/types';
import type { MorphoVaults } from './morpho/types';
import type { SiloVaults } from './silo/types';
import type { EulerEarnVaults } from './euler-earn/types';
import type { LstShareTokens } from './lst';
import type { SavingsVaults } from './savings';
import type { LagoonVaults } from './lagoon';
import type { AaveEarnVaults } from './aave-earn';
import type { UpshiftVaults } from './upshift';
import type { YearnVaults } from './yearn';
import type { HypercoreVaults } from './hypercore';
import type { GmxVaults, GmxExecutionFees } from './gmx';
import { type VaultLookupEntry } from './lookup';
/** Supported ERC-4626 vault providers. */
export type VaultProvider = 'fluid' | 'gearbox' | 'morpho' | 'lista' | 'silo' | 'euler-earn' | 'lst' | 'savings' | 'lagoon' | 'aave-earn' | 'upshift' | 'yearn' | 'hypercore' | 'gmx';
/** Chain under which the Hyperliquid HyperCore (L1) vaults are surfaced.
 *  HyperCore is not an EVM chain; we attribute its vaults to the
 *  Hyperliquid umbrella chain (HyperEVM, 999) so a single
 *  `/v1/data/vaults?chainId=999` query returns both. */
export declare const HYPERCORE_PROVIDER_CHAIN = "999";
/**
 * Per-provider payload returned by `getVaultPublicDataAll`. Each entry is
 * present only when the matching provider was requested AND its fetch
 * resolved (not when the chain has no deployment — those return an empty
 * map, which is still recorded here).
 */
export interface VaultPublicDataAll {
    fluid?: FluidFTokens;
    gearbox?: GearboxV3Pools;
    morpho?: MorphoVaults;
    /** Lista DAO earn vaults (Moolah-fork of MetaMorpho, BNB chain). Same
     *  `MorphoVaults` shape as `morpho`, but fetched on-chain via a dedicated
     *  path since the Morpho API/subgraph doesn't index the Lista fork. */
    lista?: MorphoVaults;
    silo?: SiloVaults;
    'euler-earn'?: EulerEarnVaults;
    lst?: LstShareTokens;
    savings?: SavingsVaults;
    lagoon?: LagoonVaults;
    /** Aave Earn ("stable") vaults — curator-run ERC-4626 wrappers over an
     *  Aave v3 supply position. Discovered + priced via the Aave public
     *  GraphQL API, enriched on-chain for `totalSupply`/share price. Keyed by
     *  lowercased vault address. */
    'aave-earn'?: AaveEarnVaults;
    /** Upshift curator-run ERC-4626-style yield vaults, sourced from the
     *  Upshift public REST listing. Keyed by lowercased receipt-token
     *  address. */
    upshift?: UpshiftVaults;
    /** Yearn V3 vaults (VaultV3 + TokenizedStrategy ERC-4626). Discovered
     *  via the yDaemon API; keyed by lowercased vault address. */
    yearn?: YearnVaults;
    /** Hyperliquid HyperCore (L1) perp/HLP vaults. Only populated for the
     *  Hyperliquid chain ({@link HYPERCORE_PROVIDER_CHAIN}). Keyed by
     *  lowercased vault address. */
    hypercore?: HypercoreVaults;
    /** GMX V2 GM-market and GLV-vault pool tokens (perp-DEX liquidity).
     *  Only populated on chains where GMX is deployed (Arbitrum One,
     *  Avalanche C-Chain). Keyed by lowercased token address. */
    gmx?: GmxVaults;
    /** Per-chain minimum GM/GLV execution fees (wei). Populated alongside
     *  `gmx`. Gas-price-derived, so treat as fresh-at-fetch estimates. */
    gmxExecutionFees?: GmxExecutionFees;
}
export interface GetVaultPublicDataAllOptions {
    /** Narrow Silo to a single protocol version (`v2` or `v3`). */
    siloProtocolVersion?: 'v2' | 'v3';
    /** Page size hint for Silo's GraphQL query. */
    siloLimit?: number;
}
/**
 * Combined output of `getVaultPublicDataAll`: the rich per-provider
 * payload (`data`) plus a flat address-keyed lookup (`lookup`) that
 * downstream consumers (e.g. user-balance endpoints) use without
 * branching on provider key. Both views come from the same fetch —
 * the lookup is built in-process, no extra I/O.
 */
export interface VaultPublicDataResult {
    data: VaultPublicDataAll;
    lookup: Map<string, VaultLookupEntry>;
}
/**
 * Universal vault fetcher — the vaults-side analogue of
 * `getLenderPublicDataAll`.
 *
 * Dispatches each requested provider to its dedicated fetcher and runs
 * them concurrently. Sources are mixed (Fluid + Gearbox use multicall;
 * Morpho + Silo are HTTP GraphQL), so there's no API-vs-on-chain split
 * like the lender path — every provider runs in parallel and a single
 * provider's failure does not sink the others.
 *
 * @param chainId         target chain
 * @param providers       which providers to fetch (any subset of
 *                        `'fluid' | 'gearbox' | 'morpho' | 'silo' | 'euler-earn'`)
 * @param multicallRetry  provider-level multicall executor — used by
 *                        Fluid and Gearbox; ignored when only HTTP
 *                        providers are requested
 * @param prices          optional price map keyed by oracle key /
 *                        underlying address
 * @param tokenList       optional token list for hydrating `asset`
 *                        metadata on each parsed vault
 * @param options         provider-specific knobs (Silo version filter, …)
 *
 * @returns `VaultPublicDataAll` — one key per requested provider that
 *          resolved successfully; failed providers are omitted (and
 *          logged when `VAULTS_DEBUG` is on).
 */
export declare const getVaultPublicDataAll: (chainId: string, providers: VaultProvider[], multicallRetry: MulticallRetryFunction, prices?: {
    [asset: string]: number;
}, tokenList?: GenericTokenList, options?: GetVaultPublicDataAllOptions) => Promise<VaultPublicDataResult>;
//# sourceMappingURL=fetchVaultsAll.d.ts.map