import { EulerEarn, type IEulerEarn } from "../../../entities/EulerEarn.js";
import { type Address } from "viem";
import type { DeploymentService } from "../../deploymentService/index.js";
import type { FetchAllVaultsArgs, IVaultService } from "../index.js";
import type { IEVaultService, EVaultFetchOptions } from "../eVaultService/index.js";
import type { IVaultMetaService, VaultEntity } from "../vaultMetaService/index.js";
import type { IPriceService } from "../../priceService/index.js";
import type { IRewardsService } from "../../rewardsService/index.js";
import type { IIntrinsicApyService } from "../../intrinsicApyService/index.js";
import type { IEulerLabelsService } from "../../eulerLabelsService/index.js";
import type { DataIssue, ServiceResult } from "../../../utils/entityDiagnostics.js";
export interface IEulerEarnAdapter {
    fetchVaults(chainId: number, vault: Address[]): Promise<ServiceResult<(IEulerEarn | undefined)[]>>;
    fetchAllVaults(chainId: number): Promise<ServiceResult<(IEulerEarn | undefined)[]>>;
    fetchVerifiedVaultsAddresses(chainId: number, perspectives: Address[]): Promise<Address[]>;
}
/**
 * On-chain perspectives that can be passed to fetchVerifiedVaultAddresses / fetchVerifiedVaults.
 *
 * NOTE: FACTORY only proves the vault was deployed through the EulerEarn factory - a
 * discovery/provenance signal, not a trust signal. The curated on-chain whitelist
 * (eulerEarnGovernedPerspective) is retired; trusted vault lists should be derived from
 * euler-labels (see eulerLabelsService / populateLabels) or your own allowlist.
 */
export declare enum StandardEulerEarnPerspectives {
    FACTORY = "eulerEarnFactoryPerspective"
}
export interface EulerEarnFetchOptions {
    /** When true, enables all supported populate steps and overrides granular populate flags. */
    populateAll?: boolean;
    populateStrategyVaults?: boolean;
    populateMarketPrices?: boolean;
    populateRewards?: boolean;
    populateIntrinsicApy?: boolean;
    populateLabels?: boolean;
    /** Options forwarded to EVaultService when populating strategy vaults. */
    eVaultFetchOptions?: EVaultFetchOptions;
}
export interface IEulerEarnService extends IVaultService<EulerEarn, StandardEulerEarnPerspectives> {
    fetchVault(chainId: number, vault: Address, options?: EulerEarnFetchOptions): Promise<ServiceResult<EulerEarn | undefined>>;
    fetchVaults(chainId: number, vaults: Address[], options?: EulerEarnFetchOptions): Promise<ServiceResult<(EulerEarn | undefined)[]>>;
    /**
     * Fetches all discoverable EulerEarn vaults.
     * The optional async `filter` runs after the first fetch and before populate/enrichment work,
     * so rejected vaults are skipped before additional resources are spent on them.
     */
    fetchAllVaults(chainId: number, args?: FetchAllVaultsArgs<EulerEarn, EulerEarnFetchOptions>): Promise<ServiceResult<(EulerEarn | undefined)[]>>;
    populateStrategyVaults(eulerEarns: EulerEarn[], eVaultFetchOptions?: EVaultFetchOptions): Promise<DataIssue[]>;
    populateMarketPrices(eulerEarns: EulerEarn[]): Promise<DataIssue[]>;
    populateRewards(eulerEarns: EulerEarn[]): Promise<DataIssue[]>;
    populateIntrinsicApy(eulerEarns: EulerEarn[]): Promise<DataIssue[]>;
    populateLabels(eulerEarns: EulerEarn[]): Promise<DataIssue[]>;
}
export declare class EulerEarnService implements IEulerEarnService {
    private adapter;
    private deploymentService;
    eVaultService?: IEVaultService | undefined;
    private priceService?;
    private rewardsService?;
    private intrinsicApyService?;
    private eulerLabelsService?;
    private vaultMetaService?;
    constructor(adapter: IEulerEarnAdapter, deploymentService: DeploymentService, eVaultService?: IEVaultService | undefined);
    setAdapter(adapter: IEulerEarnAdapter): void;
    setEVaultService(eVaultService: IEVaultService): void;
    setVaultMetaService(vaultMetaService: IVaultMetaService<VaultEntity>): void;
    setPriceService(service: IPriceService): void;
    setRewardsService(service: IRewardsService): void;
    setIntrinsicApyService(service: IIntrinsicApyService): void;
    setEulerLabelsService(service: IEulerLabelsService): void;
    factory(chainId: number): Address;
    fetchVault(chainId: number, vault: Address, options?: EulerEarnFetchOptions): Promise<ServiceResult<EulerEarn | undefined>>;
    fetchVaults(chainId: number, vaults: Address[], options?: EulerEarnFetchOptions): Promise<ServiceResult<(EulerEarn | undefined)[]>>;
    fetchAllVaults(chainId: number, args?: FetchAllVaultsArgs<EulerEarn, EulerEarnFetchOptions>): Promise<ServiceResult<(EulerEarn | undefined)[]>>;
    private hydrateFetchedVaults;
    populateStrategyVaults(eulerEarns: EulerEarn[], eVaultFetchOptions?: EVaultFetchOptions): Promise<DataIssue[]>;
    populateMarketPrices(eulerEarns: EulerEarn[]): Promise<DataIssue[]>;
    populateRewards(eulerEarns: EulerEarn[]): Promise<DataIssue[]>;
    populateIntrinsicApy(eulerEarns: EulerEarn[]): Promise<DataIssue[]>;
    populateLabels(eulerEarns: EulerEarn[]): Promise<DataIssue[]>;
    fetchVerifiedVaultAddresses(chainId: number, perspectives: (StandardEulerEarnPerspectives | Address)[]): Promise<Address[]>;
    fetchVerifiedVaults(chainId: number, perspectives: (StandardEulerEarnPerspectives | Address)[], options?: EulerEarnFetchOptions): Promise<ServiceResult<(EulerEarn | undefined)[]>>;
    private resolveFetchOptions;
}
//# sourceMappingURL=eulerEarnService.d.ts.map