import type { ethers } from "ethers";
import { ContractProvider } from "../../utils";
import * as CompoundV3 from "./CompoundV3Adapters";
import * as ERC4626 from "./ERC4626Adapters";
import type { DeployAdapterResult } from "./GlobalAdapters";
import * as MorphoMarketV1 from "./MorphoMarketV1Adapters";
export type AdapterType = "erc4626" | "erc4626Merkl" | "compoundV3" | "morphoMarketV1";
/**
 * Factory client — deploys adapters and looks them up by underlying.
 *
 * Owns nothing chain-specific: it delegates to per-type modules and the
 * shared `_contracts` helper.
 */
export declare class AdaptersFactoryClient {
    private cp;
    constructor(provider: ethers.Provider, signer?: ethers.Signer);
    /** Deploy an adapter of the specified type. */
    deployAdapter(type: AdapterType, parentVault: string, underlying: string, cometRewards?: string): Promise<DeployAdapterResult>;
    /**
     * Find an existing adapter for `(parentVault, underlying)`.
     * If `type` is omitted, every supported type is tried in turn and the
     * first match (non-zero address) is returned.
     */
    findAdapter(parentVault: string, underlying: string, options?: {
        type?: AdapterType;
        cometRewards?: string;
    }): Promise<string>;
    /** Check whether an account is a registered adapter of the given type. */
    isAdapter(type: AdapterType, account: string): Promise<boolean>;
    getERC4626Factory(): Promise<ethers.Contract>;
    getERC4626MerklFactory(): Promise<ethers.Contract>;
    getCompoundV3Factory(): Promise<ethers.Contract>;
    getMorphoMarketV1Factory(): Promise<ethers.Contract>;
}
/**
 * Per-adapter introspection client — wraps a single adapter address +
 * type and exposes the relevant reads.
 */
export declare class AdaptersClient {
    private cp;
    constructor(provider: ethers.Provider, signer?: ethers.Signer);
    adapter(adapterAddress: string, type: AdapterType): AdapterInstance;
    /**
     * Generic instance when the type is unknown — used for cross-type reads
     * like `getAdapterType()` and `getAdapterFactoryAddress()` which only
     * need a `factory()` getter (selector identical across types).
     */
    globalAdapter(adapterAddress: string): AdapterInstance;
}
export declare class AdapterInstance {
    readonly address: string;
    readonly type: AdapterType;
    readonly contract: ethers.Contract;
    private readonly cp;
    constructor(cp: ContractProvider, address: string, type: AdapterType);
    getIdsERC4626(): Promise<string[]>;
    getUnderlyingERC4626(): Promise<string>;
    getVaultStateERC4626(): Promise<ERC4626.ERC4626VaultState>;
    getIdsERC4626Merkl(): Promise<string[]>;
    getUnderlyingERC4626Merkl(): Promise<string>;
    getVaultStateERC4626Merkl(): Promise<ERC4626.ERC4626VaultState>;
    getIdsCompoundV3(): Promise<string[]>;
    getUnderlyingCompoundV3(): Promise<string>;
    getCometState(): Promise<CompoundV3.CometState>;
    getIdsMarketV1(marketParams: MorphoMarketV1.MarketParams): Promise<string[]>;
    getUnderlyingMarketFromAdapterV1(): Promise<string>;
    getMarketIdsLength(): Promise<number>;
    getMarketId(index: number): Promise<string>;
    getMarketState(id: string): Promise<MorphoMarketV1.MorphoMarketState>;
    /** Read the on-chain `adapterId` (bytes32) — implemented by every adapter type. */
    getAdapterId(): Promise<string>;
    getAdapterFactoryAddress(): Promise<string>;
    getAdapterType(): Promise<AdapterType | undefined>;
    /**
     * Live value of the adapter's investments (pending interest included).
     * `realAssets()` is required by `IAdapter`, so this works for any type.
     */
    getRealAssets(): Promise<bigint>;
    /** Parent vault address, exposed by every adapter type. */
    getParentVault(): Promise<string>;
    /**
     * Vault-side tracked allocation for the adapter's lone id (single-id
     * types). Lazy: excludes interest/losses since the last (de)allocate,
     * use `getRealAssets()` for the live value. For morphoMarketV1 the
     * allocation is per-market: use `getAllocationMarketV1(marketParams)`.
     */
    getAllocation(): Promise<bigint>;
    /** Vault-side tracked allocation of one market (`this/marketParams` id). */
    getAllocationMarketV1(marketParams: MorphoMarketV1.MarketParams): Promise<bigint>;
    /**
     * Live value of the adapter's position on one market by id (bytes32),
     * pending interest included: the per-market term of `realAssets()`.
     */
    getExpectedSupplyAssets(marketId: string): Promise<bigint>;
    /** Adapter's raw supply shares on one market by id (bytes32). */
    getSupplyShares(marketId: string): Promise<bigint>;
    /** Adaptive-curve IRM address baked into the adapter. */
    getAdaptiveCurveIrm(): Promise<string>;
    /** Underlying asset of the adapter (morphoMarketV1 / compoundV3 only). */
    getAsset(): Promise<string>;
    getSkimRecipient(): Promise<string>;
    setSkimRecipient(newSkimRecipient: string): Promise<ethers.TransactionResponse>;
    skim(token: string): Promise<ethers.TransactionResponse>;
    getClaimer(): Promise<string>;
    setClaimer(newClaimer: string): Promise<ethers.TransactionResponse>;
    claim(data: string): Promise<ethers.TransactionResponse>;
    getCometRewards(): Promise<string>;
    getMerklDistributor(): Promise<string>;
    getTimelock(selector: string): Promise<bigint>;
    getAbdicated(selector: string): Promise<boolean>;
    getExecutableAt(data: string): Promise<bigint>;
    submit(data: string): Promise<ethers.TransactionResponse>;
    revoke(data: string): Promise<ethers.TransactionResponse>;
    abdicate(selector: string): Promise<ethers.TransactionResponse>;
    /**
     * Write off the adapter's recorded supply shares on a market (bad debt).
     * Timelocked, must be `submit`'d first.
     */
    burnShares(marketId: string): Promise<ethers.TransactionResponse>;
    increaseTimelock(selector: string, newDuration: bigint): Promise<ethers.TransactionResponse>;
    decreaseTimelock(selector: string, newDuration: bigint): Promise<ethers.TransactionResponse>;
    private requireType;
}