import { AccrualVaultV2, AccrualVaultV2MorphoMarketV1AdapterV2, type IAccrualVaultV2Adapter, type IVaultV2Allocation, type IVaultV2BlueMarketPublicAllocatorConfig, type IVaultV2BluePublicAllocatorConfig, Market, type MarketId, VaultV2BlueMarketPublicAllocatorConfig, VaultV2BluePublicAllocatorConfig } from "@morpho-org/blue-sdk";
import { type Address, type Hash } from "viem";
import type { VaultV2BluePublicAllocatorOptions, VaultV2BlueReallocation } from "../types/index.js";
type ReadonlyMarketSnapshot = Readonly<Market>;
type ReadonlyAdapterSnapshot = Readonly<IAccrualVaultV2Adapter>;
type ReadonlyMarketAdapterSnapshot = Readonly<Omit<AccrualVaultV2MorphoMarketV1AdapterV2, "marketIds" | "supplyShares" | "markets">> & {
    readonly marketIds: readonly MarketId[];
    readonly supplyShares: Readonly<Record<MarketId, bigint>>;
    readonly markets: readonly ReadonlyMarketSnapshot[];
};
type ReadonlyVaultSnapshot = Readonly<Omit<AccrualVaultV2, "adapters" | "liquidityAllocations" | "accrualLiquidityAdapter" | "accrualAdapters" | "forceDeallocatePenalties">> & {
    readonly adapters: readonly Address[];
    readonly liquidityAllocations: readonly Readonly<IVaultV2Allocation>[] | undefined;
    readonly accrualLiquidityAdapter: ReadonlyAdapterSnapshot | undefined;
    readonly accrualAdapters: readonly ReadonlyAdapterSnapshot[];
    readonly forceDeallocatePenalties: Readonly<Record<Address, bigint>>;
};
/** Input state required to simulate Vault V2 BluePublicAllocator reallocations. */
export interface InputVaultV2BlueReallocationData {
    /** Chain id associated with the fetched state. */
    readonly chainId: number;
    /** Markets indexed by market id. */
    readonly markets?: Readonly<Record<MarketId, ReadonlyMarketSnapshot | undefined>>;
    /** Accrued Vault V2 entities indexed by vault address. */
    readonly vaults?: Readonly<Record<Address, ReadonlyVaultSnapshot | undefined>>;
    /** Vault cap state indexed by vault address and derived allocation id. */
    readonly allocations?: Readonly<Record<Address, Readonly<Record<Hash, IVaultV2Allocation | undefined>> | undefined>>;
    /** Vault-wide BluePublicAllocator configuration indexed by vault address. */
    readonly publicAllocatorConfigs?: Readonly<Record<Address, IVaultV2BluePublicAllocatorConfig | undefined>>;
    /**
     * BluePublicAllocator-active adapters indexed by vault address.
     * Arrays, readonly arrays, sets, and other iterables are copied to sets
     * without changing address casing.
     */
    readonly activeAdapters?: Readonly<Record<Address, Iterable<Address> | undefined>>;
    /** Adapter-market BluePublicAllocator configuration indexed by vault and `adapterMarketCapId`. */
    readonly marketPublicAllocatorConfigs?: Readonly<Record<Address, Readonly<Record<Hash, IVaultV2BlueMarketPublicAllocatorConfig | undefined>> | undefined>>;
}
/**
 * Immutable-by-convention state container for Vault V2 BluePublicAllocator simulations.
 *
 * Constructor inputs are cloned. Every simulated reallocation returns a new
 * instance. Planning keeps the transaction-scoped `firstTotalAssets`
 * denominator outside the durable snapshot while applying reallocations in
 * contract order. Penalty donations update simulated vault accounting but are
 * excluded from same-plan idle liquidity so round-up dust cannot create
 * self-replenishing candidates.
 * Address keys and values retain their supplied casing; lookups compare them
 * case-insensitively.
 *
 * @example
 * ```ts
 * import { markets } from "@morpho-org/morpho-test";
 * import { createPublicClient, http } from "viem";
 * import { mainnet } from "viem/chains";
 * import { morphoViemExtension } from "@morpho-org/morpho-sdk";
 * import type { VaultV2BlueReallocationData } from "@morpho-org/morpho-sdk/entities";
 *
 * const client = createPublicClient({ chain: mainnet, transport: http() })
 *   .extend(morphoViemExtension());
 * const marketParams = markets[mainnet.id].usdc_wbtc;
 * const market = client.morpho.blue(marketParams, mainnet.id);
 * const block = await client.getBlock();
 * const keyrockUsdcVaultV2 = "0x04422053aDDbc9bB2759b248B574e3FCA76Bc145";
 * const data: VaultV2BlueReallocationData =
 *   await market.getVaultV2BlueReallocationData({
 *     vaultAddresses: [keyrockUsdcVaultV2],
 *     block: { number: block.number, timestamp: block.timestamp },
 *   });
 * ```
 */
export declare class VaultV2BlueReallocationData implements InputVaultV2BlueReallocationData {
    /** Mutable market state used only by cloned simulation transitions. */
    private readonly mutableMarkets;
    /** Mutable vault state used only by cloned simulation transitions. */
    private readonly mutableVaults;
    /** Mutable allocation state used only by cloned simulation transitions. */
    private readonly mutableAllocations;
    /** Chain id associated with this snapshot. */
    readonly chainId: number;
    /** Markets indexed by market id. */
    readonly markets: Readonly<Record<MarketId, ReadonlyMarketSnapshot | undefined>>;
    /** Vault V2 entities indexed by address. */
    readonly vaults: Readonly<Record<Address, ReadonlyVaultSnapshot | undefined>>;
    /** Vault cap state indexed by vault and derived allocation id. */
    readonly allocations: Readonly<Record<Address, Readonly<Record<Hash, Readonly<IVaultV2Allocation> | undefined>> | undefined>>;
    /** Vault-wide allocator configuration indexed by vault. */
    readonly publicAllocatorConfigs: Readonly<Record<Address, VaultV2BluePublicAllocatorConfig | undefined>>;
    /** BluePublicAllocator-active adapters indexed by vault address, preserving vault and adapter casing. */
    readonly activeAdapters: Readonly<Record<Address, ReadonlySet<Address> | undefined>>;
    /** Adapter-market allocator configuration indexed by vault and market-params id. */
    readonly marketPublicAllocatorConfigs: Readonly<Record<Address, Readonly<Record<Hash, VaultV2BlueMarketPublicAllocatorConfig | undefined>> | undefined>>;
    /**
     * Creates a cloned Vault V2 reallocation snapshot.
     *
     * @param input - State fetched at one consistent block.
     * @throws {UnsupportedBlueVaultV2AdapterError} when a vault contains an unsupported adapter type.
     */
    constructor(input: InputVaultV2BlueReallocationData);
    /**
     * Clones the complete simulation snapshot.
     *
     * @returns A deep clone of this simulation state.
     * @example
     * ```ts
     * import { markets } from "@morpho-org/morpho-test";
     * import { createPublicClient, http } from "viem";
     * import { mainnet } from "viem/chains";
     * import { morphoViemExtension } from "@morpho-org/morpho-sdk";
     * import type { VaultV2BlueReallocationData } from "@morpho-org/morpho-sdk/entities";
     *
     * const client = createPublicClient({ chain: mainnet, transport: http() })
     *   .extend(morphoViemExtension());
     * const marketParams = markets[mainnet.id].usdc_wbtc;
     * const market = client.morpho.blue(marketParams, mainnet.id);
     * const block = await client.getBlock();
     * const keyrockUsdcVaultV2 = "0x04422053aDDbc9bB2759b248B574e3FCA76Bc145";
     * const data = await market.getVaultV2BlueReallocationData({
     *   vaultAddresses: [keyrockUsdcVaultV2],
     *   block: { number: block.number, timestamp: block.timestamp },
     * });
     * const cloned: VaultV2BlueReallocationData = data.clone();
     * ```
     */
    clone(): VaultV2BlueReallocationData;
    /**
     * Gets a market from this snapshot.
     *
     * @param marketId - Market id to read.
     * @returns The market state.
     * @throws {UnknownReallocationMarketError} when the market is absent.
     * @example
     * ```ts
     * import { markets } from "@morpho-org/morpho-test";
     * import { createPublicClient, http } from "viem";
     * import { mainnet } from "viem/chains";
     * import { morphoViemExtension } from "@morpho-org/morpho-sdk";
     * import type { VaultV2BlueReallocationData } from "@morpho-org/morpho-sdk/entities";
     *
     * const client = createPublicClient({ chain: mainnet, transport: http() })
     *   .extend(morphoViemExtension());
     * const marketParams = markets[mainnet.id].usdc_wbtc;
     * const market = client.morpho.blue(marketParams, mainnet.id);
     * const block = await client.getBlock();
     * const keyrockUsdcVaultV2 = "0x04422053aDDbc9bB2759b248B574e3FCA76Bc145";
     * const data = await market.getVaultV2BlueReallocationData({
     *   vaultAddresses: [keyrockUsdcVaultV2],
     *   block: { number: block.number, timestamp: block.timestamp },
     * });
     * const targetMarket: ReturnType<
     *   VaultV2BlueReallocationData["getMarket"]
     * > = data.getMarket(marketParams.id);
     * ```
     */
    getMarket(marketId: MarketId): ReadonlyMarketSnapshot;
    /**
     * Gets a Vault V2 from this snapshot.
     *
     * @param vault - Vault V2 address.
     * @returns The accrued Vault V2 state.
     * @throws {UnknownReallocationVaultError} when the vault is absent.
     * @example
     * ```ts
     * import { markets } from "@morpho-org/morpho-test";
     * import { createPublicClient, http } from "viem";
     * import { mainnet } from "viem/chains";
     * import { morphoViemExtension } from "@morpho-org/morpho-sdk";
     * import type { VaultV2BlueReallocationData } from "@morpho-org/morpho-sdk/entities";
     *
     * const client = createPublicClient({ chain: mainnet, transport: http() })
     *   .extend(morphoViemExtension());
     * const marketParams = markets[mainnet.id].usdc_wbtc;
     * const market = client.morpho.blue(marketParams, mainnet.id);
     * const block = await client.getBlock();
     * const keyrockUsdcVaultV2 = "0x04422053aDDbc9bB2759b248B574e3FCA76Bc145";
     * const data = await market.getVaultV2BlueReallocationData({
     *   vaultAddresses: [keyrockUsdcVaultV2],
     *   block: { number: block.number, timestamp: block.timestamp },
     * });
     * const vault: ReturnType<VaultV2BlueReallocationData["getVault"]> =
     *   data.getVault(keyrockUsdcVaultV2);
     * ```
     */
    getVault(vault: Address): ReadonlyVaultSnapshot;
    private getMutableVault;
    /**
     * Gets one Vault V2 allocation record.
     *
     * @param vault - Vault V2 address.
     * @param id - Derived allocation id.
     * @returns The allocation and cap state.
     * @throws {UnknownReallocationAllocationError} when the record is absent.
     * @example
     * ```ts
     * import { markets } from "@morpho-org/morpho-test";
     * import { createPublicClient, http, type Hash } from "viem";
     * import { mainnet } from "viem/chains";
     * import { morphoViemExtension } from "@morpho-org/morpho-sdk";
     * import type { VaultV2BlueReallocationData } from "@morpho-org/morpho-sdk/entities";
     *
     * const client = createPublicClient({ chain: mainnet, transport: http() })
     *   .extend(morphoViemExtension());
     * const marketParams = markets[mainnet.id].usdc_wbtc;
     * const market = client.morpho.blue(marketParams, mainnet.id);
     * const block = await client.getBlock();
     * const keyrockUsdcVaultV2 = "0x04422053aDDbc9bB2759b248B574e3FCA76Bc145";
     * const data = await market.getVaultV2BlueReallocationData({
     *   vaultAddresses: [keyrockUsdcVaultV2],
     *   block: { number: block.number, timestamp: block.timestamp },
     * });
     * const [allocationId] = Object.keys(
     *   data.allocations[keyrockUsdcVaultV2] ?? {},
     * ) as Hash[];
     * const allocation: ReturnType<
     *   VaultV2BlueReallocationData["getAllocation"]
     * > = data.getAllocation(keyrockUsdcVaultV2, allocationId!);
     * ```
     */
    getAllocation(vault: Address, id: Hash): Readonly<IVaultV2Allocation>;
    /**
     * Gets one vault-wide BluePublicAllocator configuration.
     *
     * @param vault - Vault V2 address.
     * @returns The vault-wide allocator configuration.
     * @throws {UnknownReallocationPublicAllocatorConfigError} when it is absent.
     * @example
     * ```ts
     * import { markets } from "@morpho-org/morpho-test";
     * import { createPublicClient, http } from "viem";
     * import { mainnet } from "viem/chains";
     * import { morphoViemExtension } from "@morpho-org/morpho-sdk";
     * import type { VaultV2BlueReallocationData } from "@morpho-org/morpho-sdk/entities";
     *
     * const client = createPublicClient({ chain: mainnet, transport: http() })
     *   .extend(morphoViemExtension());
     * const marketParams = markets[mainnet.id].usdc_wbtc;
     * const market = client.morpho.blue(marketParams, mainnet.id);
     * const block = await client.getBlock();
     * const keyrockUsdcVaultV2 = "0x04422053aDDbc9bB2759b248B574e3FCA76Bc145";
     * const data = await market.getVaultV2BlueReallocationData({
     *   vaultAddresses: [keyrockUsdcVaultV2],
     *   block: { number: block.number, timestamp: block.timestamp },
     * });
     * const config: ReturnType<
     *   VaultV2BlueReallocationData["getPublicAllocatorConfig"]
     * > = data.getPublicAllocatorConfig(keyrockUsdcVaultV2);
     * ```
     */
    getPublicAllocatorConfig(vault: Address): VaultV2BluePublicAllocatorConfig;
    /**
     * Gets fetched allocator authorization state, including an explicit absent value.
     *
     * @param vault - Vault V2 address.
     * @returns The allocator config, or `undefined` when the fetched vault has not authorized it.
     * @throws {UnknownReallocationPublicAllocatorConfigError} when the fetch state is absent.
     */
    private getOptionalPublicAllocatorConfig;
    /**
     * Gets the BluePublicAllocator-active adapters for a Vault V2.
     *
     * @param vault - Vault V2 address.
     * @returns The active adapter addresses in their supplied casing, or an empty set when none are active.
     * @throws {UnknownReallocationActiveAdaptersError} when the active-adapter state is absent.
     * @example
     * ```ts
     * import { markets } from "@morpho-org/morpho-test";
     * import { createPublicClient, http, type Address } from "viem";
     * import { mainnet } from "viem/chains";
     * import { morphoViemExtension } from "@morpho-org/morpho-sdk";
     *
     * const client = createPublicClient({ chain: mainnet, transport: http() })
     *   .extend(morphoViemExtension());
     * const marketParams = markets[mainnet.id].usdc_wbtc;
     * const market = client.morpho.blue(marketParams, mainnet.id);
     * const block = await client.getBlock();
     * const keyrockUsdcVaultV2 = "0x04422053aDDbc9bB2759b248B574e3FCA76Bc145";
     * const data = await market.getVaultV2BlueReallocationData({
     *   vaultAddresses: [keyrockUsdcVaultV2],
     *   block: { number: block.number, timestamp: block.timestamp },
     * });
     * const activeAdapters: ReadonlySet<Address> =
     *   data.getActiveAdapters(keyrockUsdcVaultV2);
     * ```
     */
    getActiveAdapters(vault: Address): ReadonlySet<Address>;
    /**
     * Gets one adapter-market BluePublicAllocator configuration.
     *
     * @param vault - Vault V2 address.
     * @param adapterMarketCapId - Adapter-scoped market cap id.
     * @returns The allocator cap and permissions.
     * @throws {UnknownReallocationMarketPublicAllocatorConfigError} when it is absent.
     * @example
     * ```ts
     * import { markets } from "@morpho-org/morpho-test";
     * import { createPublicClient, http, type Hash } from "viem";
     * import { mainnet } from "viem/chains";
     * import { morphoViemExtension } from "@morpho-org/morpho-sdk";
     * import type { VaultV2BlueReallocationData } from "@morpho-org/morpho-sdk/entities";
     *
     * const client = createPublicClient({ chain: mainnet, transport: http() })
     *   .extend(morphoViemExtension());
     * const marketParams = markets[mainnet.id].usdc_wbtc;
     * const market = client.morpho.blue(marketParams, mainnet.id);
     * const block = await client.getBlock();
     * const keyrockUsdcVaultV2 = "0x04422053aDDbc9bB2759b248B574e3FCA76Bc145";
     * const data = await market.getVaultV2BlueReallocationData({
     *   vaultAddresses: [keyrockUsdcVaultV2],
     *   block: { number: block.number, timestamp: block.timestamp },
     * });
     * const [adapterMarketCapId] = Object.keys(
     *   data.marketPublicAllocatorConfigs[keyrockUsdcVaultV2] ?? {},
     * ) as Hash[];
     * const config: ReturnType<
     *   VaultV2BlueReallocationData["getMarketPublicAllocatorConfig"]
     * > = data.getMarketPublicAllocatorConfig(
     *   keyrockUsdcVaultV2,
     *   adapterMarketCapId!,
     * );
     * ```
     */
    getMarketPublicAllocatorConfig(vault: Address, adapterMarketCapId: Hash): VaultV2BlueMarketPublicAllocatorConfig;
    /**
     * Gets a supported MorphoMarketV1AdapterV2 from a Vault V2.
     *
     * @param vault - Vault V2 address.
     * @param adapter - Adapter address.
     * @returns The accrued adapter state.
     * @throws {UnknownReallocationAdapterError} when it is absent or unsupported.
     * @example
     * ```ts
     * import { markets } from "@morpho-org/morpho-test";
     * import { createPublicClient, http } from "viem";
     * import { mainnet } from "viem/chains";
     * import { morphoViemExtension } from "@morpho-org/morpho-sdk";
     * import type { VaultV2BlueReallocationData } from "@morpho-org/morpho-sdk/entities";
     *
     * const client = createPublicClient({ chain: mainnet, transport: http() })
     *   .extend(morphoViemExtension());
     * const marketParams = markets[mainnet.id].usdc_wbtc;
     * const market = client.morpho.blue(marketParams, mainnet.id);
     * const block = await client.getBlock();
     * const keyrockUsdcVaultV2 = "0x04422053aDDbc9bB2759b248B574e3FCA76Bc145";
     * const data = await market.getVaultV2BlueReallocationData({
     *   vaultAddresses: [keyrockUsdcVaultV2],
     *   block: { number: block.number, timestamp: block.timestamp },
     * });
     * const [adapterAddress] = data.activeAdapters[keyrockUsdcVaultV2] ?? [];
     * const adapter: ReturnType<VaultV2BlueReallocationData["getAdapter"]> =
     *   data.getAdapter(keyrockUsdcVaultV2, adapterAddress!);
     * ```
     */
    getAdapter(vault: Address, adapter: Address): ReadonlyMarketAdapterSnapshot;
    private getMutableAdapter;
    /**
     * Computes Vault V2 BluePublicAllocator calls available for a target market.
     *
     * Without `options.operation`, discovers every friendly call. With an
     * operation, targets the amount required by that borrow or loan-asset
     * withdrawal and falls back to 100% source utilization only when friendly
     * liquidity cannot cover the absolute shortfall. A shared relative-cap lower
     * bound may require one call to exceed the targeted amount. Friendly source
     * utilization defaults to 90% and is configurable through
     * `options.maxWithdrawalUtilization`. Vaults whose configured penalty exceeds
     * `options.maxPenalty` are ignored. By default, only zero-penalty vaults are
     * considered. Targets with no remaining supply or allocator capacity are skipped before
     * projecting source interest. The adapter's minimum share minting requirement, supply-share
     * limits, and target absolute or zero relative caps are checked against a one-asset deposit.
     * Shared cap IDs that a source withdrawal can reduce remain eligible, as do deposits whose
     * allocation does not increase after rounding.
     *
     * Shared-cap discovery is conservative. Operation planning searches at most
     * 1,024 base units above its targeted amount for the nearest executable fit.
     * Full-liquidity discovery omits a candidate when its non-shared maximum
     * violates a shared cap instead of scanning smaller base-unit amounts. These
     * bounds can understate executable liquidity in rounding-only edge cases.
     *
     * @param marketId - Target Blue market id.
     * @param options - Optional discovery controls and operation to support.
     * @returns Flat action-ready reallocations and their post-simulation state.
     * @throws {UnsupportedBlueMarketIrmError} when a market with positive debt uses an unsupported IRM.
     * @throws {NegativeInputError} when `maxWithdrawalUtilization` or `maxPenalty` is negative.
     * @throws {InputExceedsMaxError} when `maxWithdrawalUtilization` or `maxPenalty` exceeds WAD.
     * @throws {NonPositiveInputError} when the operation amount is not positive and planning is enabled.
     * @throws {UnknownReallocationMarketError} when a required market is absent.
     * @throws {UnknownReallocationVaultError} when configured vault state is absent.
     * @throws {UnknownReallocationPublicAllocatorConfigError} when allocator authorization state is absent.
     * @throws {UnknownReallocationActiveAdaptersError} when active-adapter state is absent for a vault.
     * @throws {UnknownReallocationMarketPublicAllocatorConfigError} when an adapter-market allocator configuration is absent.
     * @throws {UnknownReallocationAllocationError} when required allocation state is absent.
     * @throws {InsufficientSharedLiquidityError} when selected liquidity cannot cover the absolute shortfall.
     * @throws {ReallocationWithdrawExceedsMarketSupplyError} when a withdraw exceeds market supply.
     * @example
     * ```ts
     * import { markets } from "@morpho-org/morpho-test";
     * import { createPublicClient, http } from "viem";
     * import { mainnet } from "viem/chains";
     * import {
     *   morphoViemExtension,
     *   type VaultV2BlueReallocation,
     * } from "@morpho-org/morpho-sdk";
     * import type { VaultV2BlueReallocationData } from "@morpho-org/morpho-sdk/entities";
     *
     * const client = createPublicClient({ chain: mainnet, transport: http() })
     *   .extend(morphoViemExtension());
     * const marketParams = markets[mainnet.id].usdc_wbtc;
     * const market = client.morpho.blue(marketParams, mainnet.id);
     * const block = await client.getBlock();
     * const keyrockUsdcVaultV2 = "0x04422053aDDbc9bB2759b248B574e3FCA76Bc145";
     * const data = await market.getVaultV2BlueReallocationData({
     *   vaultAddresses: [keyrockUsdcVaultV2],
     *   block: { number: block.number, timestamp: block.timestamp },
     * });
     * const result: {
     *   readonly reallocations: readonly VaultV2BlueReallocation[];
     *   readonly data: VaultV2BlueReallocationData;
     * } = data.computeVaultV2BlueReallocations(marketParams.id, {
     *   timestamp: block.timestamp,
     * });
     * ```
     */
    computeVaultV2BlueReallocations(marketId: MarketId, options?: VaultV2BluePublicAllocatorOptions & {
        readonly operation?: {
            readonly type: "borrow" | "withdraw";
            readonly amount: bigint;
        };
    }): {
        readonly reallocations: readonly VaultV2BlueReallocation[];
        readonly data: VaultV2BlueReallocationData;
    };
    private computeVaultV2BlueReallocationsAtUtilizationInPlace;
    /**
     * Sums friendly Vault V2 shared liquidity available to a target market.
     *
     * @param marketId - Target Blue market id.
     * @param options - Optional timestamp, enable flag, vault allowlist, source utilization ceiling, and maximum penalty.
     * @returns Reallocatable market and idle assets, or `0n` when none are available; rounding-only shared-cap fits may be conservatively omitted.
     * @throws {UnsupportedBlueMarketIrmError} when a market with positive debt uses an unsupported IRM.
     * @throws {NegativeInputError} when `maxWithdrawalUtilization` or `maxPenalty` is negative.
     * @throws {InputExceedsMaxError} when `maxWithdrawalUtilization` or `maxPenalty` exceeds WAD.
     * @throws {UnknownReallocationMarketError} when a required market is absent.
     * @throws {UnknownReallocationVaultError} when configured vault state is absent.
     * @throws {UnknownReallocationPublicAllocatorConfigError} when allocator authorization state is absent.
     * @throws {UnknownReallocationActiveAdaptersError} when active-adapter state is absent for a vault.
     * @throws {UnknownReallocationMarketPublicAllocatorConfigError} when an adapter-market allocator configuration is absent.
     * @throws {UnknownReallocationAllocationError} when required allocation state is absent.
     * @example
     * ```ts
     * import { markets } from "@morpho-org/morpho-test";
     * import { createPublicClient, http } from "viem";
     * import { mainnet } from "viem/chains";
     * import { morphoViemExtension } from "@morpho-org/morpho-sdk";
     *
     * const client = createPublicClient({ chain: mainnet, transport: http() })
     *   .extend(morphoViemExtension());
     * const marketParams = markets[mainnet.id].usdc_wbtc;
     * const market = client.morpho.blue(marketParams, mainnet.id);
     * const block = await client.getBlock();
     * const keyrockUsdcVaultV2 = "0x04422053aDDbc9bB2759b248B574e3FCA76Bc145";
     * const data = await market.getVaultV2BlueReallocationData({
     *   vaultAddresses: [keyrockUsdcVaultV2],
     *   block: { number: block.number, timestamp: block.timestamp },
     * });
     * const liquidity: bigint = data.getPublicReallocationLiquidity(
     *   marketParams.id,
     *   { timestamp: block.timestamp },
     * );
     * ```
     */
    getPublicReallocationLiquidity(marketId: MarketId, options?: VaultV2BluePublicAllocatorOptions): bigint;
    /**
     * Computes borrow liquidity to a target utilization, including friendly
     * Vault V2 public reallocations.
     *
     * @param marketId - Target Blue market id.
     * @param utilization - Desired utilization, scaled by WAD. Defaults to 90%.
     * @param options - Optional timestamp, enable flag, vault allowlist, source utilization ceiling, and maximum penalty.
     * @returns Borrowable assets while remaining at or below `utilization`; rounding-only shared-cap fits may be conservatively omitted.
     * @throws {UnsupportedBlueMarketIrmError} when a market with positive debt uses an unsupported IRM.
     * @throws {NegativeInputError} when `maxWithdrawalUtilization` or `maxPenalty` is negative.
     * @throws {InputExceedsMaxError} when `maxWithdrawalUtilization` or `maxPenalty` exceeds WAD.
     * @throws {UnknownReallocationMarketError} when a required market is absent.
     * @throws {UnknownReallocationVaultError} when configured vault state is absent.
     * @throws {UnknownReallocationPublicAllocatorConfigError} when allocator authorization state is absent.
     * @throws {UnknownReallocationActiveAdaptersError} when active-adapter state is absent for a vault.
     * @throws {UnknownReallocationMarketPublicAllocatorConfigError} when an adapter-market allocator configuration is absent.
     * @throws {UnknownReallocationAllocationError} when required allocation state is absent.
     * @example
     * ```ts
     * import { markets } from "@morpho-org/morpho-test";
     * import { createPublicClient, http, parseEther } from "viem";
     * import { mainnet } from "viem/chains";
     * import { morphoViemExtension } from "@morpho-org/morpho-sdk";
     *
     * const client = createPublicClient({ chain: mainnet, transport: http() })
     *   .extend(morphoViemExtension());
     * const marketParams = markets[mainnet.id].usdc_wbtc;
     * const market = client.morpho.blue(marketParams, mainnet.id);
     * const block = await client.getBlock();
     * const keyrockUsdcVaultV2 = "0x04422053aDDbc9bB2759b248B574e3FCA76Bc145";
     * const data = await market.getVaultV2BlueReallocationData({
     *   vaultAddresses: [keyrockUsdcVaultV2],
     *   block: { number: block.number, timestamp: block.timestamp },
     * });
     * const liquidity: bigint = data.getAvailableLiquidityToUtilization(
     *   marketParams.id,
     *   parseEther("0.9"),
     *   { timestamp: block.timestamp },
     * );
     * ```
     */
    getAvailableLiquidityToUtilization(marketId: MarketId, utilization?: bigint, options?: VaultV2BluePublicAllocatorOptions): bigint;
    private getLatestSnapshotTimestamp;
    private applyPublicReallocation;
    /** Updates canonical markets in bulk and refreshes only dependent adapter views. */
    private setMarkets;
}
export {};