import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PopulatedTransaction, Signer, utils } from "ethers";
import type { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
import type { Listener, Provider } from "@ethersproject/providers";
import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent, PromiseOrValue } from "../../common";
export interface VaultUpgradableInterface extends utils.Interface {
    functions: {
        "BASE_UNIT()": FunctionFragment;
        "UNDERLYING()": FunctionFragment;
        "addStrategy(address)": FunctionFragment;
        "allowance(address,address)": FunctionFragment;
        "approve(address,uint256)": FunctionFragment;
        "balanceOf(address)": FunctionFragment;
        "balanceOfUnderlying(address)": FunctionFragment;
        "bulkAllow(address[])": FunctionFragment;
        "claimFees(uint256)": FunctionFragment;
        "cleanWithdrawalQueue()": FunctionFragment;
        "decimals()": FunctionFragment;
        "decreaseAllowance(address,uint256)": FunctionFragment;
        "deposit(uint256)": FunctionFragment;
        "depositIntoStrategy(address,uint256)": FunctionFragment;
        "distrustStrategy(address)": FunctionFragment;
        "exchangeRate()": FunctionFragment;
        "exchangeRateLock(uint8)": FunctionFragment;
        "feePercent()": FunctionFragment;
        "getMaxTvl()": FunctionFragment;
        "getStrategyData(address)": FunctionFragment;
        "getWithdrawalQueue()": FunctionFragment;
        "harvest(address[])": FunctionFragment;
        "harvestDelay()": FunctionFragment;
        "harvestWindow()": FunctionFragment;
        "increaseAllowance(address,uint256)": FunctionFragment;
        "initialize(address,address,address,uint256,uint64,uint128)": FunctionFragment;
        "isAllowed(address)": FunctionFragment;
        "isManager(address)": FunctionFragment;
        "isPublic()": FunctionFragment;
        "lastHarvest()": FunctionFragment;
        "lastHarvestWindowStart()": FunctionFragment;
        "lockedProfit()": FunctionFragment;
        "maxLockedLoss()": FunctionFragment;
        "maxLockedProfit()": FunctionFragment;
        "migrateStrategy(address,address,uint256)": FunctionFragment;
        "name()": FunctionFragment;
        "nextHarvestDelay()": FunctionFragment;
        "owner()": FunctionFragment;
        "popFromWithdrawalQueue()": FunctionFragment;
        "pushToWithdrawalQueue(address)": FunctionFragment;
        "pushToWithdrawalQueueValidated(address)": FunctionFragment;
        "redeem(uint256)": FunctionFragment;
        "renounceOwnership()": FunctionFragment;
        "replaceWithdrawalQueueIndex(uint256,address)": FunctionFragment;
        "replaceWithdrawalQueueIndexWithTip(uint256)": FunctionFragment;
        "seizeStrategy(address,address[])": FunctionFragment;
        "setAllowed(address,bool)": FunctionFragment;
        "setFeePercent(uint256)": FunctionFragment;
        "setHarvestDelay(uint64)": FunctionFragment;
        "setHarvestWindow(uint128)": FunctionFragment;
        "setManager(address,bool)": FunctionFragment;
        "setMaxTvl(uint256)": FunctionFragment;
        "setPublic(bool)": FunctionFragment;
        "setTargetFloatPercent(uint256)": FunctionFragment;
        "setUnderlyingIsWETH(bool)": FunctionFragment;
        "setWithdrawalQueue(address[])": FunctionFragment;
        "swapWithdrawalQueueIndexes(uint256,uint256)": FunctionFragment;
        "symbol()": FunctionFragment;
        "targetFloatPercent()": FunctionFragment;
        "totalFloat()": FunctionFragment;
        "totalHoldings()": FunctionFragment;
        "totalHoldingsLock(uint8)": FunctionFragment;
        "totalStrategyHoldings()": FunctionFragment;
        "totalSupply()": FunctionFragment;
        "transfer(address,uint256)": FunctionFragment;
        "transferFrom(address,address,uint256)": FunctionFragment;
        "transferOwnership(address)": FunctionFragment;
        "trustStrategy(address)": FunctionFragment;
        "underlyingIsWETH()": FunctionFragment;
        "updateStratTvl()": FunctionFragment;
        "version()": FunctionFragment;
        "withdraw(uint256)": FunctionFragment;
        "withdrawFromStrategy(address,uint256)": FunctionFragment;
        "withdrawalQueue(uint256)": FunctionFragment;
    };
    getFunction(nameOrSignatureOrTopic: "BASE_UNIT" | "UNDERLYING" | "addStrategy" | "allowance" | "approve" | "balanceOf" | "balanceOfUnderlying" | "bulkAllow" | "claimFees" | "cleanWithdrawalQueue" | "decimals" | "decreaseAllowance" | "deposit" | "depositIntoStrategy" | "distrustStrategy" | "exchangeRate" | "exchangeRateLock" | "feePercent" | "getMaxTvl" | "getStrategyData" | "getWithdrawalQueue" | "harvest" | "harvestDelay" | "harvestWindow" | "increaseAllowance" | "initialize" | "isAllowed" | "isManager" | "isPublic" | "lastHarvest" | "lastHarvestWindowStart" | "lockedProfit" | "maxLockedLoss" | "maxLockedProfit" | "migrateStrategy" | "name" | "nextHarvestDelay" | "owner" | "popFromWithdrawalQueue" | "pushToWithdrawalQueue" | "pushToWithdrawalQueueValidated" | "redeem" | "renounceOwnership" | "replaceWithdrawalQueueIndex" | "replaceWithdrawalQueueIndexWithTip" | "seizeStrategy" | "setAllowed" | "setFeePercent" | "setHarvestDelay" | "setHarvestWindow" | "setManager" | "setMaxTvl" | "setPublic" | "setTargetFloatPercent" | "setUnderlyingIsWETH" | "setWithdrawalQueue" | "swapWithdrawalQueueIndexes" | "symbol" | "targetFloatPercent" | "totalFloat" | "totalHoldings" | "totalHoldingsLock" | "totalStrategyHoldings" | "totalSupply" | "transfer" | "transferFrom" | "transferOwnership" | "trustStrategy" | "underlyingIsWETH" | "updateStratTvl" | "version" | "withdraw" | "withdrawFromStrategy" | "withdrawalQueue"): FunctionFragment;
    encodeFunctionData(functionFragment: "BASE_UNIT", values?: undefined): string;
    encodeFunctionData(functionFragment: "UNDERLYING", values?: undefined): string;
    encodeFunctionData(functionFragment: "addStrategy", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "allowance", values: [PromiseOrValue<string>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "approve", values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "balanceOf", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "balanceOfUnderlying", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "bulkAllow", values: [PromiseOrValue<string>[]]): string;
    encodeFunctionData(functionFragment: "claimFees", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "cleanWithdrawalQueue", values?: undefined): string;
    encodeFunctionData(functionFragment: "decimals", values?: undefined): string;
    encodeFunctionData(functionFragment: "decreaseAllowance", values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "deposit", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "depositIntoStrategy", values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "distrustStrategy", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "exchangeRate", values?: undefined): string;
    encodeFunctionData(functionFragment: "exchangeRateLock", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "feePercent", values?: undefined): string;
    encodeFunctionData(functionFragment: "getMaxTvl", values?: undefined): string;
    encodeFunctionData(functionFragment: "getStrategyData", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "getWithdrawalQueue", values?: undefined): string;
    encodeFunctionData(functionFragment: "harvest", values: [PromiseOrValue<string>[]]): string;
    encodeFunctionData(functionFragment: "harvestDelay", values?: undefined): string;
    encodeFunctionData(functionFragment: "harvestWindow", values?: undefined): string;
    encodeFunctionData(functionFragment: "increaseAllowance", values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "initialize", values: [
        PromiseOrValue<string>,
        PromiseOrValue<string>,
        PromiseOrValue<string>,
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<BigNumberish>
    ]): string;
    encodeFunctionData(functionFragment: "isAllowed", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "isManager", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "isPublic", values?: undefined): string;
    encodeFunctionData(functionFragment: "lastHarvest", values?: undefined): string;
    encodeFunctionData(functionFragment: "lastHarvestWindowStart", values?: undefined): string;
    encodeFunctionData(functionFragment: "lockedProfit", values?: undefined): string;
    encodeFunctionData(functionFragment: "maxLockedLoss", values?: undefined): string;
    encodeFunctionData(functionFragment: "maxLockedProfit", values?: undefined): string;
    encodeFunctionData(functionFragment: "migrateStrategy", values: [
        PromiseOrValue<string>,
        PromiseOrValue<string>,
        PromiseOrValue<BigNumberish>
    ]): string;
    encodeFunctionData(functionFragment: "name", values?: undefined): string;
    encodeFunctionData(functionFragment: "nextHarvestDelay", values?: undefined): string;
    encodeFunctionData(functionFragment: "owner", values?: undefined): string;
    encodeFunctionData(functionFragment: "popFromWithdrawalQueue", values?: undefined): string;
    encodeFunctionData(functionFragment: "pushToWithdrawalQueue", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "pushToWithdrawalQueueValidated", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "redeem", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "renounceOwnership", values?: undefined): string;
    encodeFunctionData(functionFragment: "replaceWithdrawalQueueIndex", values: [PromiseOrValue<BigNumberish>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "replaceWithdrawalQueueIndexWithTip", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "seizeStrategy", values: [PromiseOrValue<string>, PromiseOrValue<string>[]]): string;
    encodeFunctionData(functionFragment: "setAllowed", values: [PromiseOrValue<string>, PromiseOrValue<boolean>]): string;
    encodeFunctionData(functionFragment: "setFeePercent", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "setHarvestDelay", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "setHarvestWindow", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "setManager", values: [PromiseOrValue<string>, PromiseOrValue<boolean>]): string;
    encodeFunctionData(functionFragment: "setMaxTvl", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "setPublic", values: [PromiseOrValue<boolean>]): string;
    encodeFunctionData(functionFragment: "setTargetFloatPercent", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "setUnderlyingIsWETH", values: [PromiseOrValue<boolean>]): string;
    encodeFunctionData(functionFragment: "setWithdrawalQueue", values: [PromiseOrValue<string>[]]): string;
    encodeFunctionData(functionFragment: "swapWithdrawalQueueIndexes", values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "symbol", values?: undefined): string;
    encodeFunctionData(functionFragment: "targetFloatPercent", values?: undefined): string;
    encodeFunctionData(functionFragment: "totalFloat", values?: undefined): string;
    encodeFunctionData(functionFragment: "totalHoldings", values?: undefined): string;
    encodeFunctionData(functionFragment: "totalHoldingsLock", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "totalStrategyHoldings", values?: undefined): string;
    encodeFunctionData(functionFragment: "totalSupply", values?: undefined): string;
    encodeFunctionData(functionFragment: "transfer", values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "transferFrom", values: [
        PromiseOrValue<string>,
        PromiseOrValue<string>,
        PromiseOrValue<BigNumberish>
    ]): string;
    encodeFunctionData(functionFragment: "transferOwnership", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "trustStrategy", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "underlyingIsWETH", values?: undefined): string;
    encodeFunctionData(functionFragment: "updateStratTvl", values?: undefined): string;
    encodeFunctionData(functionFragment: "version", values?: undefined): string;
    encodeFunctionData(functionFragment: "withdraw", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "withdrawFromStrategy", values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "withdrawalQueue", values: [PromiseOrValue<BigNumberish>]): string;
    decodeFunctionResult(functionFragment: "BASE_UNIT", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "UNDERLYING", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "addStrategy", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "balanceOfUnderlying", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "bulkAllow", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "claimFees", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "cleanWithdrawalQueue", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "decreaseAllowance", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "deposit", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "depositIntoStrategy", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "distrustStrategy", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "exchangeRate", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "exchangeRateLock", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "feePercent", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getMaxTvl", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getStrategyData", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getWithdrawalQueue", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "harvest", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "harvestDelay", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "harvestWindow", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "increaseAllowance", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "isAllowed", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "isManager", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "isPublic", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "lastHarvest", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "lastHarvestWindowStart", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "lockedProfit", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "maxLockedLoss", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "maxLockedProfit", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "migrateStrategy", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "nextHarvestDelay", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "popFromWithdrawalQueue", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "pushToWithdrawalQueue", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "pushToWithdrawalQueueValidated", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "redeem", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "renounceOwnership", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "replaceWithdrawalQueueIndex", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "replaceWithdrawalQueueIndexWithTip", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "seizeStrategy", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setAllowed", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setFeePercent", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setHarvestDelay", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setHarvestWindow", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setManager", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setMaxTvl", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setPublic", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setTargetFloatPercent", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setUnderlyingIsWETH", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setWithdrawalQueue", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "swapWithdrawalQueueIndexes", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "targetFloatPercent", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "totalFloat", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "totalHoldings", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "totalHoldingsLock", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "totalStrategyHoldings", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "totalSupply", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "transferFrom", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "transferOwnership", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "trustStrategy", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "underlyingIsWETH", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "updateStratTvl", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "version", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "withdrawFromStrategy", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "withdrawalQueue", data: BytesLike): Result;
    events: {
        "AllowedUpdate(address,bool)": EventFragment;
        "Approval(address,address,uint256)": EventFragment;
        "Deposit(address,uint256)": EventFragment;
        "FeePercentUpdated(address,uint256)": EventFragment;
        "FeesClaimed(address,uint256)": EventFragment;
        "Harvest(address,address[])": EventFragment;
        "HarvestDelayUpdateScheduled(address,uint64)": EventFragment;
        "HarvestDelayUpdated(address,uint64)": EventFragment;
        "HarvestWindowUpdated(address,uint128)": EventFragment;
        "Initialized(address)": EventFragment;
        "ManagerUpdate(address,bool)": EventFragment;
        "MaxTvlUpdated(uint256)": EventFragment;
        "OwnershipTransferred(address,address)": EventFragment;
        "SetPublic(bool)": EventFragment;
        "StrategyDeposit(address,address,uint256)": EventFragment;
        "StrategyDistrusted(address,address)": EventFragment;
        "StrategySeized(address,address)": EventFragment;
        "StrategyTrusted(address,address)": EventFragment;
        "StrategyWithdrawal(address,address,uint256)": EventFragment;
        "TargetFloatPercentUpdated(address,uint256)": EventFragment;
        "Transfer(address,address,uint256)": EventFragment;
        "UnderlyingIsWETHUpdated(address,bool)": EventFragment;
        "Withdraw(address,uint256)": EventFragment;
        "WithdrawalQueueIndexReplaced(address,uint256,address,address)": EventFragment;
        "WithdrawalQueueIndexReplacedWithTip(address,uint256,address,address)": EventFragment;
        "WithdrawalQueueIndexesSwapped(address,uint256,uint256,address,address)": EventFragment;
        "WithdrawalQueuePopped(address,address)": EventFragment;
        "WithdrawalQueuePushed(address,address)": EventFragment;
        "WithdrawalQueueSet(address,address[])": EventFragment;
    };
    getEvent(nameOrSignatureOrTopic: "AllowedUpdate"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Deposit"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "FeePercentUpdated"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "FeesClaimed"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Harvest"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "HarvestDelayUpdateScheduled"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "HarvestDelayUpdated"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "HarvestWindowUpdated"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "ManagerUpdate"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "MaxTvlUpdated"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "SetPublic"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "StrategyDeposit"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "StrategyDistrusted"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "StrategySeized"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "StrategyTrusted"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "StrategyWithdrawal"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "TargetFloatPercentUpdated"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "UnderlyingIsWETHUpdated"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Withdraw"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "WithdrawalQueueIndexReplaced"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "WithdrawalQueueIndexReplacedWithTip"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "WithdrawalQueueIndexesSwapped"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "WithdrawalQueuePopped"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "WithdrawalQueuePushed"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "WithdrawalQueueSet"): EventFragment;
}
export interface AllowedUpdateEventObject {
    account: string;
    isManager: boolean;
}
export type AllowedUpdateEvent = TypedEvent<[
    string,
    boolean
], AllowedUpdateEventObject>;
export type AllowedUpdateEventFilter = TypedEventFilter<AllowedUpdateEvent>;
export interface ApprovalEventObject {
    owner: string;
    spender: string;
    value: BigNumber;
}
export type ApprovalEvent = TypedEvent<[
    string,
    string,
    BigNumber
], ApprovalEventObject>;
export type ApprovalEventFilter = TypedEventFilter<ApprovalEvent>;
export interface DepositEventObject {
    user: string;
    underlyingAmount: BigNumber;
}
export type DepositEvent = TypedEvent<[string, BigNumber], DepositEventObject>;
export type DepositEventFilter = TypedEventFilter<DepositEvent>;
export interface FeePercentUpdatedEventObject {
    user: string;
    newFeePercent: BigNumber;
}
export type FeePercentUpdatedEvent = TypedEvent<[
    string,
    BigNumber
], FeePercentUpdatedEventObject>;
export type FeePercentUpdatedEventFilter = TypedEventFilter<FeePercentUpdatedEvent>;
export interface FeesClaimedEventObject {
    user: string;
    rvTokenAmount: BigNumber;
}
export type FeesClaimedEvent = TypedEvent<[
    string,
    BigNumber
], FeesClaimedEventObject>;
export type FeesClaimedEventFilter = TypedEventFilter<FeesClaimedEvent>;
export interface HarvestEventObject {
    user: string;
    strategies: string[];
}
export type HarvestEvent = TypedEvent<[string, string[]], HarvestEventObject>;
export type HarvestEventFilter = TypedEventFilter<HarvestEvent>;
export interface HarvestDelayUpdateScheduledEventObject {
    user: string;
    newHarvestDelay: BigNumber;
}
export type HarvestDelayUpdateScheduledEvent = TypedEvent<[
    string,
    BigNumber
], HarvestDelayUpdateScheduledEventObject>;
export type HarvestDelayUpdateScheduledEventFilter = TypedEventFilter<HarvestDelayUpdateScheduledEvent>;
export interface HarvestDelayUpdatedEventObject {
    user: string;
    newHarvestDelay: BigNumber;
}
export type HarvestDelayUpdatedEvent = TypedEvent<[
    string,
    BigNumber
], HarvestDelayUpdatedEventObject>;
export type HarvestDelayUpdatedEventFilter = TypedEventFilter<HarvestDelayUpdatedEvent>;
export interface HarvestWindowUpdatedEventObject {
    user: string;
    newHarvestWindow: BigNumber;
}
export type HarvestWindowUpdatedEvent = TypedEvent<[
    string,
    BigNumber
], HarvestWindowUpdatedEventObject>;
export type HarvestWindowUpdatedEventFilter = TypedEventFilter<HarvestWindowUpdatedEvent>;
export interface InitializedEventObject {
    user: string;
}
export type InitializedEvent = TypedEvent<[string], InitializedEventObject>;
export type InitializedEventFilter = TypedEventFilter<InitializedEvent>;
export interface ManagerUpdateEventObject {
    account: string;
    isManager: boolean;
}
export type ManagerUpdateEvent = TypedEvent<[
    string,
    boolean
], ManagerUpdateEventObject>;
export type ManagerUpdateEventFilter = TypedEventFilter<ManagerUpdateEvent>;
export interface MaxTvlUpdatedEventObject {
    maxTvl: BigNumber;
}
export type MaxTvlUpdatedEvent = TypedEvent<[
    BigNumber
], MaxTvlUpdatedEventObject>;
export type MaxTvlUpdatedEventFilter = TypedEventFilter<MaxTvlUpdatedEvent>;
export interface OwnershipTransferredEventObject {
    previousOwner: string;
    newOwner: string;
}
export type OwnershipTransferredEvent = TypedEvent<[
    string,
    string
], OwnershipTransferredEventObject>;
export type OwnershipTransferredEventFilter = TypedEventFilter<OwnershipTransferredEvent>;
export interface SetPublicEventObject {
    setPublic: boolean;
}
export type SetPublicEvent = TypedEvent<[boolean], SetPublicEventObject>;
export type SetPublicEventFilter = TypedEventFilter<SetPublicEvent>;
export interface StrategyDepositEventObject {
    user: string;
    strategy: string;
    underlyingAmount: BigNumber;
}
export type StrategyDepositEvent = TypedEvent<[
    string,
    string,
    BigNumber
], StrategyDepositEventObject>;
export type StrategyDepositEventFilter = TypedEventFilter<StrategyDepositEvent>;
export interface StrategyDistrustedEventObject {
    user: string;
    strategy: string;
}
export type StrategyDistrustedEvent = TypedEvent<[
    string,
    string
], StrategyDistrustedEventObject>;
export type StrategyDistrustedEventFilter = TypedEventFilter<StrategyDistrustedEvent>;
export interface StrategySeizedEventObject {
    user: string;
    strategy: string;
}
export type StrategySeizedEvent = TypedEvent<[
    string,
    string
], StrategySeizedEventObject>;
export type StrategySeizedEventFilter = TypedEventFilter<StrategySeizedEvent>;
export interface StrategyTrustedEventObject {
    user: string;
    strategy: string;
}
export type StrategyTrustedEvent = TypedEvent<[
    string,
    string
], StrategyTrustedEventObject>;
export type StrategyTrustedEventFilter = TypedEventFilter<StrategyTrustedEvent>;
export interface StrategyWithdrawalEventObject {
    user: string;
    strategy: string;
    underlyingAmount: BigNumber;
}
export type StrategyWithdrawalEvent = TypedEvent<[
    string,
    string,
    BigNumber
], StrategyWithdrawalEventObject>;
export type StrategyWithdrawalEventFilter = TypedEventFilter<StrategyWithdrawalEvent>;
export interface TargetFloatPercentUpdatedEventObject {
    user: string;
    newTargetFloatPercent: BigNumber;
}
export type TargetFloatPercentUpdatedEvent = TypedEvent<[
    string,
    BigNumber
], TargetFloatPercentUpdatedEventObject>;
export type TargetFloatPercentUpdatedEventFilter = TypedEventFilter<TargetFloatPercentUpdatedEvent>;
export interface TransferEventObject {
    from: string;
    to: string;
    value: BigNumber;
}
export type TransferEvent = TypedEvent<[
    string,
    string,
    BigNumber
], TransferEventObject>;
export type TransferEventFilter = TypedEventFilter<TransferEvent>;
export interface UnderlyingIsWETHUpdatedEventObject {
    user: string;
    newUnderlyingIsWETH: boolean;
}
export type UnderlyingIsWETHUpdatedEvent = TypedEvent<[
    string,
    boolean
], UnderlyingIsWETHUpdatedEventObject>;
export type UnderlyingIsWETHUpdatedEventFilter = TypedEventFilter<UnderlyingIsWETHUpdatedEvent>;
export interface WithdrawEventObject {
    user: string;
    underlyingAmount: BigNumber;
}
export type WithdrawEvent = TypedEvent<[
    string,
    BigNumber
], WithdrawEventObject>;
export type WithdrawEventFilter = TypedEventFilter<WithdrawEvent>;
export interface WithdrawalQueueIndexReplacedEventObject {
    user: string;
    index: BigNumber;
    replacedStrategy: string;
    replacementStrategy: string;
}
export type WithdrawalQueueIndexReplacedEvent = TypedEvent<[
    string,
    BigNumber,
    string,
    string
], WithdrawalQueueIndexReplacedEventObject>;
export type WithdrawalQueueIndexReplacedEventFilter = TypedEventFilter<WithdrawalQueueIndexReplacedEvent>;
export interface WithdrawalQueueIndexReplacedWithTipEventObject {
    user: string;
    index: BigNumber;
    replacedStrategy: string;
    previousTipStrategy: string;
}
export type WithdrawalQueueIndexReplacedWithTipEvent = TypedEvent<[
    string,
    BigNumber,
    string,
    string
], WithdrawalQueueIndexReplacedWithTipEventObject>;
export type WithdrawalQueueIndexReplacedWithTipEventFilter = TypedEventFilter<WithdrawalQueueIndexReplacedWithTipEvent>;
export interface WithdrawalQueueIndexesSwappedEventObject {
    user: string;
    index1: BigNumber;
    index2: BigNumber;
    newStrategy1: string;
    newStrategy2: string;
}
export type WithdrawalQueueIndexesSwappedEvent = TypedEvent<[
    string,
    BigNumber,
    BigNumber,
    string,
    string
], WithdrawalQueueIndexesSwappedEventObject>;
export type WithdrawalQueueIndexesSwappedEventFilter = TypedEventFilter<WithdrawalQueueIndexesSwappedEvent>;
export interface WithdrawalQueuePoppedEventObject {
    user: string;
    poppedStrategy: string;
}
export type WithdrawalQueuePoppedEvent = TypedEvent<[
    string,
    string
], WithdrawalQueuePoppedEventObject>;
export type WithdrawalQueuePoppedEventFilter = TypedEventFilter<WithdrawalQueuePoppedEvent>;
export interface WithdrawalQueuePushedEventObject {
    user: string;
    pushedStrategy: string;
}
export type WithdrawalQueuePushedEvent = TypedEvent<[
    string,
    string
], WithdrawalQueuePushedEventObject>;
export type WithdrawalQueuePushedEventFilter = TypedEventFilter<WithdrawalQueuePushedEvent>;
export interface WithdrawalQueueSetEventObject {
    user: string;
    replacedWithdrawalQueue: string[];
}
export type WithdrawalQueueSetEvent = TypedEvent<[
    string,
    string[]
], WithdrawalQueueSetEventObject>;
export type WithdrawalQueueSetEventFilter = TypedEventFilter<WithdrawalQueueSetEvent>;
export interface VaultUpgradable extends BaseContract {
    connect(signerOrProvider: Signer | Provider | string): this;
    attach(addressOrName: string): this;
    deployed(): Promise<this>;
    interface: VaultUpgradableInterface;
    queryFilter<TEvent extends TypedEvent>(event: TypedEventFilter<TEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TEvent>>;
    listeners<TEvent extends TypedEvent>(eventFilter?: TypedEventFilter<TEvent>): Array<TypedListener<TEvent>>;
    listeners(eventName?: string): Array<Listener>;
    removeAllListeners<TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>): this;
    removeAllListeners(eventName?: string): this;
    off: OnEvent<this>;
    on: OnEvent<this>;
    once: OnEvent<this>;
    removeListener: OnEvent<this>;
    functions: {
        BASE_UNIT(overrides?: CallOverrides): Promise<[BigNumber]>;
        UNDERLYING(overrides?: CallOverrides): Promise<[string]>;
        addStrategy(strategy: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        allowance(owner: PromiseOrValue<string>, spender: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
        approve(spender: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        balanceOf(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
        balanceOfUnderlying(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
        bulkAllow(users: PromiseOrValue<string>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        claimFees(rvTokenAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        cleanWithdrawalQueue(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        decimals(overrides?: CallOverrides): Promise<[number]>;
        decreaseAllowance(spender: PromiseOrValue<string>, subtractedValue: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        deposit(underlyingAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        depositIntoStrategy(strategy: PromiseOrValue<string>, underlyingAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        distrustStrategy(strategy: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        exchangeRate(overrides?: CallOverrides): Promise<[BigNumber]>;
        exchangeRateLock(lock: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[BigNumber]>;
        feePercent(overrides?: CallOverrides): Promise<[BigNumber]>;
        getMaxTvl(overrides?: CallOverrides): Promise<[BigNumber] & {
            maxTvl: BigNumber;
        }>;
        getStrategyData(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean, BigNumber] & {
            trusted: boolean;
            balance: BigNumber;
        }>;
        getWithdrawalQueue(overrides?: CallOverrides): Promise<[string[]]>;
        harvest(strategies: PromiseOrValue<string>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        harvestDelay(overrides?: CallOverrides): Promise<[BigNumber]>;
        harvestWindow(overrides?: CallOverrides): Promise<[BigNumber]>;
        increaseAllowance(spender: PromiseOrValue<string>, addedValue: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        initialize(_UNDERLYING: PromiseOrValue<string>, _owner: PromiseOrValue<string>, _manager: PromiseOrValue<string>, _feePercent: PromiseOrValue<BigNumberish>, _harvestDelay: PromiseOrValue<BigNumberish>, _harvestWindow: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        isAllowed(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>;
        isManager(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>;
        isPublic(overrides?: CallOverrides): Promise<[boolean]>;
        lastHarvest(overrides?: CallOverrides): Promise<[BigNumber]>;
        lastHarvestWindowStart(overrides?: CallOverrides): Promise<[BigNumber]>;
        lockedProfit(overrides?: CallOverrides): Promise<[BigNumber, BigNumber]>;
        maxLockedLoss(overrides?: CallOverrides): Promise<[BigNumber]>;
        maxLockedProfit(overrides?: CallOverrides): Promise<[BigNumber]>;
        migrateStrategy(prevStrategy: PromiseOrValue<string>, newStrategy: PromiseOrValue<string>, queueIndex: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        name(overrides?: CallOverrides): Promise<[string]>;
        nextHarvestDelay(overrides?: CallOverrides): Promise<[BigNumber]>;
        owner(overrides?: CallOverrides): Promise<[string]>;
        popFromWithdrawalQueue(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        pushToWithdrawalQueue(strategy: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        pushToWithdrawalQueueValidated(strategy: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        redeem(rvTokenAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        renounceOwnership(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        replaceWithdrawalQueueIndex(index: PromiseOrValue<BigNumberish>, replacementStrategy: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        replaceWithdrawalQueueIndexWithTip(index: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        seizeStrategy(strategy: PromiseOrValue<string>, tokens: PromiseOrValue<string>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setAllowed(user: PromiseOrValue<string>, _isManager: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setFeePercent(newFeePercent: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setHarvestDelay(newHarvestDelay: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setHarvestWindow(newHarvestWindow: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setManager(user: PromiseOrValue<string>, _isManager: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setMaxTvl(maxTvl_: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setPublic(isPublic_: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setTargetFloatPercent(newTargetFloatPercent: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setUnderlyingIsWETH(newUnderlyingIsWETH: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setWithdrawalQueue(newQueue: PromiseOrValue<string>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        swapWithdrawalQueueIndexes(index1: PromiseOrValue<BigNumberish>, index2: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        symbol(overrides?: CallOverrides): Promise<[string]>;
        targetFloatPercent(overrides?: CallOverrides): Promise<[BigNumber]>;
        totalFloat(overrides?: CallOverrides): Promise<[BigNumber]>;
        totalHoldings(overrides?: CallOverrides): Promise<[BigNumber]>;
        totalHoldingsLock(lock: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[BigNumber] & {
            totalUnderlyingHeld: BigNumber;
        }>;
        totalStrategyHoldings(overrides?: CallOverrides): Promise<[BigNumber]>;
        totalSupply(overrides?: CallOverrides): Promise<[BigNumber]>;
        transfer(recipient: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        transferFrom(sender: PromiseOrValue<string>, recipient: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        trustStrategy(strategy: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        underlyingIsWETH(overrides?: CallOverrides): Promise<[boolean]>;
        updateStratTvl(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        version(overrides?: CallOverrides): Promise<[BigNumber]>;
        withdraw(underlyingAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        withdrawFromStrategy(strategy: PromiseOrValue<string>, underlyingAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        withdrawalQueue(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[string]>;
    };
    BASE_UNIT(overrides?: CallOverrides): Promise<BigNumber>;
    UNDERLYING(overrides?: CallOverrides): Promise<string>;
    addStrategy(strategy: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    allowance(owner: PromiseOrValue<string>, spender: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
    approve(spender: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    balanceOf(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
    balanceOfUnderlying(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
    bulkAllow(users: PromiseOrValue<string>[], overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    claimFees(rvTokenAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    cleanWithdrawalQueue(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    decimals(overrides?: CallOverrides): Promise<number>;
    decreaseAllowance(spender: PromiseOrValue<string>, subtractedValue: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    deposit(underlyingAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    depositIntoStrategy(strategy: PromiseOrValue<string>, underlyingAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    distrustStrategy(strategy: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    exchangeRate(overrides?: CallOverrides): Promise<BigNumber>;
    exchangeRateLock(lock: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
    feePercent(overrides?: CallOverrides): Promise<BigNumber>;
    getMaxTvl(overrides?: CallOverrides): Promise<BigNumber>;
    getStrategyData(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean, BigNumber] & {
        trusted: boolean;
        balance: BigNumber;
    }>;
    getWithdrawalQueue(overrides?: CallOverrides): Promise<string[]>;
    harvest(strategies: PromiseOrValue<string>[], overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    harvestDelay(overrides?: CallOverrides): Promise<BigNumber>;
    harvestWindow(overrides?: CallOverrides): Promise<BigNumber>;
    increaseAllowance(spender: PromiseOrValue<string>, addedValue: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    initialize(_UNDERLYING: PromiseOrValue<string>, _owner: PromiseOrValue<string>, _manager: PromiseOrValue<string>, _feePercent: PromiseOrValue<BigNumberish>, _harvestDelay: PromiseOrValue<BigNumberish>, _harvestWindow: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    isAllowed(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
    isManager(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
    isPublic(overrides?: CallOverrides): Promise<boolean>;
    lastHarvest(overrides?: CallOverrides): Promise<BigNumber>;
    lastHarvestWindowStart(overrides?: CallOverrides): Promise<BigNumber>;
    lockedProfit(overrides?: CallOverrides): Promise<[BigNumber, BigNumber]>;
    maxLockedLoss(overrides?: CallOverrides): Promise<BigNumber>;
    maxLockedProfit(overrides?: CallOverrides): Promise<BigNumber>;
    migrateStrategy(prevStrategy: PromiseOrValue<string>, newStrategy: PromiseOrValue<string>, queueIndex: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    name(overrides?: CallOverrides): Promise<string>;
    nextHarvestDelay(overrides?: CallOverrides): Promise<BigNumber>;
    owner(overrides?: CallOverrides): Promise<string>;
    popFromWithdrawalQueue(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    pushToWithdrawalQueue(strategy: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    pushToWithdrawalQueueValidated(strategy: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    redeem(rvTokenAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    renounceOwnership(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    replaceWithdrawalQueueIndex(index: PromiseOrValue<BigNumberish>, replacementStrategy: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    replaceWithdrawalQueueIndexWithTip(index: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    seizeStrategy(strategy: PromiseOrValue<string>, tokens: PromiseOrValue<string>[], overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setAllowed(user: PromiseOrValue<string>, _isManager: PromiseOrValue<boolean>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setFeePercent(newFeePercent: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setHarvestDelay(newHarvestDelay: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setHarvestWindow(newHarvestWindow: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setManager(user: PromiseOrValue<string>, _isManager: PromiseOrValue<boolean>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setMaxTvl(maxTvl_: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setPublic(isPublic_: PromiseOrValue<boolean>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setTargetFloatPercent(newTargetFloatPercent: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setUnderlyingIsWETH(newUnderlyingIsWETH: PromiseOrValue<boolean>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setWithdrawalQueue(newQueue: PromiseOrValue<string>[], overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    swapWithdrawalQueueIndexes(index1: PromiseOrValue<BigNumberish>, index2: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    symbol(overrides?: CallOverrides): Promise<string>;
    targetFloatPercent(overrides?: CallOverrides): Promise<BigNumber>;
    totalFloat(overrides?: CallOverrides): Promise<BigNumber>;
    totalHoldings(overrides?: CallOverrides): Promise<BigNumber>;
    totalHoldingsLock(lock: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
    totalStrategyHoldings(overrides?: CallOverrides): Promise<BigNumber>;
    totalSupply(overrides?: CallOverrides): Promise<BigNumber>;
    transfer(recipient: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    transferFrom(sender: PromiseOrValue<string>, recipient: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    trustStrategy(strategy: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    underlyingIsWETH(overrides?: CallOverrides): Promise<boolean>;
    updateStratTvl(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    version(overrides?: CallOverrides): Promise<BigNumber>;
    withdraw(underlyingAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    withdrawFromStrategy(strategy: PromiseOrValue<string>, underlyingAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    withdrawalQueue(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
    callStatic: {
        BASE_UNIT(overrides?: CallOverrides): Promise<BigNumber>;
        UNDERLYING(overrides?: CallOverrides): Promise<string>;
        addStrategy(strategy: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        allowance(owner: PromiseOrValue<string>, spender: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        approve(spender: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<boolean>;
        balanceOf(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        balanceOfUnderlying(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        bulkAllow(users: PromiseOrValue<string>[], overrides?: CallOverrides): Promise<void>;
        claimFees(rvTokenAmount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        cleanWithdrawalQueue(overrides?: CallOverrides): Promise<void>;
        decimals(overrides?: CallOverrides): Promise<number>;
        decreaseAllowance(spender: PromiseOrValue<string>, subtractedValue: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<boolean>;
        deposit(underlyingAmount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        depositIntoStrategy(strategy: PromiseOrValue<string>, underlyingAmount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        distrustStrategy(strategy: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        exchangeRate(overrides?: CallOverrides): Promise<BigNumber>;
        exchangeRateLock(lock: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
        feePercent(overrides?: CallOverrides): Promise<BigNumber>;
        getMaxTvl(overrides?: CallOverrides): Promise<BigNumber>;
        getStrategyData(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean, BigNumber] & {
            trusted: boolean;
            balance: BigNumber;
        }>;
        getWithdrawalQueue(overrides?: CallOverrides): Promise<string[]>;
        harvest(strategies: PromiseOrValue<string>[], overrides?: CallOverrides): Promise<void>;
        harvestDelay(overrides?: CallOverrides): Promise<BigNumber>;
        harvestWindow(overrides?: CallOverrides): Promise<BigNumber>;
        increaseAllowance(spender: PromiseOrValue<string>, addedValue: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<boolean>;
        initialize(_UNDERLYING: PromiseOrValue<string>, _owner: PromiseOrValue<string>, _manager: PromiseOrValue<string>, _feePercent: PromiseOrValue<BigNumberish>, _harvestDelay: PromiseOrValue<BigNumberish>, _harvestWindow: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        isAllowed(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
        isManager(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
        isPublic(overrides?: CallOverrides): Promise<boolean>;
        lastHarvest(overrides?: CallOverrides): Promise<BigNumber>;
        lastHarvestWindowStart(overrides?: CallOverrides): Promise<BigNumber>;
        lockedProfit(overrides?: CallOverrides): Promise<[BigNumber, BigNumber]>;
        maxLockedLoss(overrides?: CallOverrides): Promise<BigNumber>;
        maxLockedProfit(overrides?: CallOverrides): Promise<BigNumber>;
        migrateStrategy(prevStrategy: PromiseOrValue<string>, newStrategy: PromiseOrValue<string>, queueIndex: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        name(overrides?: CallOverrides): Promise<string>;
        nextHarvestDelay(overrides?: CallOverrides): Promise<BigNumber>;
        owner(overrides?: CallOverrides): Promise<string>;
        popFromWithdrawalQueue(overrides?: CallOverrides): Promise<void>;
        pushToWithdrawalQueue(strategy: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        pushToWithdrawalQueueValidated(strategy: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        redeem(rvTokenAmount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        renounceOwnership(overrides?: CallOverrides): Promise<void>;
        replaceWithdrawalQueueIndex(index: PromiseOrValue<BigNumberish>, replacementStrategy: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        replaceWithdrawalQueueIndexWithTip(index: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        seizeStrategy(strategy: PromiseOrValue<string>, tokens: PromiseOrValue<string>[], overrides?: CallOverrides): Promise<void>;
        setAllowed(user: PromiseOrValue<string>, _isManager: PromiseOrValue<boolean>, overrides?: CallOverrides): Promise<void>;
        setFeePercent(newFeePercent: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        setHarvestDelay(newHarvestDelay: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        setHarvestWindow(newHarvestWindow: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        setManager(user: PromiseOrValue<string>, _isManager: PromiseOrValue<boolean>, overrides?: CallOverrides): Promise<void>;
        setMaxTvl(maxTvl_: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        setPublic(isPublic_: PromiseOrValue<boolean>, overrides?: CallOverrides): Promise<void>;
        setTargetFloatPercent(newTargetFloatPercent: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        setUnderlyingIsWETH(newUnderlyingIsWETH: PromiseOrValue<boolean>, overrides?: CallOverrides): Promise<void>;
        setWithdrawalQueue(newQueue: PromiseOrValue<string>[], overrides?: CallOverrides): Promise<void>;
        swapWithdrawalQueueIndexes(index1: PromiseOrValue<BigNumberish>, index2: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        symbol(overrides?: CallOverrides): Promise<string>;
        targetFloatPercent(overrides?: CallOverrides): Promise<BigNumber>;
        totalFloat(overrides?: CallOverrides): Promise<BigNumber>;
        totalHoldings(overrides?: CallOverrides): Promise<BigNumber>;
        totalHoldingsLock(lock: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
        totalStrategyHoldings(overrides?: CallOverrides): Promise<BigNumber>;
        totalSupply(overrides?: CallOverrides): Promise<BigNumber>;
        transfer(recipient: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<boolean>;
        transferFrom(sender: PromiseOrValue<string>, recipient: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<boolean>;
        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        trustStrategy(strategy: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        underlyingIsWETH(overrides?: CallOverrides): Promise<boolean>;
        updateStratTvl(overrides?: CallOverrides): Promise<BigNumber>;
        version(overrides?: CallOverrides): Promise<BigNumber>;
        withdraw(underlyingAmount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        withdrawFromStrategy(strategy: PromiseOrValue<string>, underlyingAmount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        withdrawalQueue(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
    };
    filters: {
        "AllowedUpdate(address,bool)"(account?: PromiseOrValue<string> | null, isManager?: null): AllowedUpdateEventFilter;
        AllowedUpdate(account?: PromiseOrValue<string> | null, isManager?: null): AllowedUpdateEventFilter;
        "Approval(address,address,uint256)"(owner?: PromiseOrValue<string> | null, spender?: PromiseOrValue<string> | null, value?: null): ApprovalEventFilter;
        Approval(owner?: PromiseOrValue<string> | null, spender?: PromiseOrValue<string> | null, value?: null): ApprovalEventFilter;
        "Deposit(address,uint256)"(user?: PromiseOrValue<string> | null, underlyingAmount?: null): DepositEventFilter;
        Deposit(user?: PromiseOrValue<string> | null, underlyingAmount?: null): DepositEventFilter;
        "FeePercentUpdated(address,uint256)"(user?: PromiseOrValue<string> | null, newFeePercent?: null): FeePercentUpdatedEventFilter;
        FeePercentUpdated(user?: PromiseOrValue<string> | null, newFeePercent?: null): FeePercentUpdatedEventFilter;
        "FeesClaimed(address,uint256)"(user?: PromiseOrValue<string> | null, rvTokenAmount?: null): FeesClaimedEventFilter;
        FeesClaimed(user?: PromiseOrValue<string> | null, rvTokenAmount?: null): FeesClaimedEventFilter;
        "Harvest(address,address[])"(user?: PromiseOrValue<string> | null, strategies?: null): HarvestEventFilter;
        Harvest(user?: PromiseOrValue<string> | null, strategies?: null): HarvestEventFilter;
        "HarvestDelayUpdateScheduled(address,uint64)"(user?: PromiseOrValue<string> | null, newHarvestDelay?: null): HarvestDelayUpdateScheduledEventFilter;
        HarvestDelayUpdateScheduled(user?: PromiseOrValue<string> | null, newHarvestDelay?: null): HarvestDelayUpdateScheduledEventFilter;
        "HarvestDelayUpdated(address,uint64)"(user?: PromiseOrValue<string> | null, newHarvestDelay?: null): HarvestDelayUpdatedEventFilter;
        HarvestDelayUpdated(user?: PromiseOrValue<string> | null, newHarvestDelay?: null): HarvestDelayUpdatedEventFilter;
        "HarvestWindowUpdated(address,uint128)"(user?: PromiseOrValue<string> | null, newHarvestWindow?: null): HarvestWindowUpdatedEventFilter;
        HarvestWindowUpdated(user?: PromiseOrValue<string> | null, newHarvestWindow?: null): HarvestWindowUpdatedEventFilter;
        "Initialized(address)"(user?: PromiseOrValue<string> | null): InitializedEventFilter;
        Initialized(user?: PromiseOrValue<string> | null): InitializedEventFilter;
        "ManagerUpdate(address,bool)"(account?: PromiseOrValue<string> | null, isManager?: null): ManagerUpdateEventFilter;
        ManagerUpdate(account?: PromiseOrValue<string> | null, isManager?: null): ManagerUpdateEventFilter;
        "MaxTvlUpdated(uint256)"(maxTvl?: null): MaxTvlUpdatedEventFilter;
        MaxTvlUpdated(maxTvl?: null): MaxTvlUpdatedEventFilter;
        "OwnershipTransferred(address,address)"(previousOwner?: PromiseOrValue<string> | null, newOwner?: PromiseOrValue<string> | null): OwnershipTransferredEventFilter;
        OwnershipTransferred(previousOwner?: PromiseOrValue<string> | null, newOwner?: PromiseOrValue<string> | null): OwnershipTransferredEventFilter;
        "SetPublic(bool)"(setPublic?: null): SetPublicEventFilter;
        SetPublic(setPublic?: null): SetPublicEventFilter;
        "StrategyDeposit(address,address,uint256)"(user?: PromiseOrValue<string> | null, strategy?: PromiseOrValue<string> | null, underlyingAmount?: null): StrategyDepositEventFilter;
        StrategyDeposit(user?: PromiseOrValue<string> | null, strategy?: PromiseOrValue<string> | null, underlyingAmount?: null): StrategyDepositEventFilter;
        "StrategyDistrusted(address,address)"(user?: PromiseOrValue<string> | null, strategy?: PromiseOrValue<string> | null): StrategyDistrustedEventFilter;
        StrategyDistrusted(user?: PromiseOrValue<string> | null, strategy?: PromiseOrValue<string> | null): StrategyDistrustedEventFilter;
        "StrategySeized(address,address)"(user?: PromiseOrValue<string> | null, strategy?: PromiseOrValue<string> | null): StrategySeizedEventFilter;
        StrategySeized(user?: PromiseOrValue<string> | null, strategy?: PromiseOrValue<string> | null): StrategySeizedEventFilter;
        "StrategyTrusted(address,address)"(user?: PromiseOrValue<string> | null, strategy?: PromiseOrValue<string> | null): StrategyTrustedEventFilter;
        StrategyTrusted(user?: PromiseOrValue<string> | null, strategy?: PromiseOrValue<string> | null): StrategyTrustedEventFilter;
        "StrategyWithdrawal(address,address,uint256)"(user?: PromiseOrValue<string> | null, strategy?: PromiseOrValue<string> | null, underlyingAmount?: null): StrategyWithdrawalEventFilter;
        StrategyWithdrawal(user?: PromiseOrValue<string> | null, strategy?: PromiseOrValue<string> | null, underlyingAmount?: null): StrategyWithdrawalEventFilter;
        "TargetFloatPercentUpdated(address,uint256)"(user?: PromiseOrValue<string> | null, newTargetFloatPercent?: null): TargetFloatPercentUpdatedEventFilter;
        TargetFloatPercentUpdated(user?: PromiseOrValue<string> | null, newTargetFloatPercent?: null): TargetFloatPercentUpdatedEventFilter;
        "Transfer(address,address,uint256)"(from?: PromiseOrValue<string> | null, to?: PromiseOrValue<string> | null, value?: null): TransferEventFilter;
        Transfer(from?: PromiseOrValue<string> | null, to?: PromiseOrValue<string> | null, value?: null): TransferEventFilter;
        "UnderlyingIsWETHUpdated(address,bool)"(user?: PromiseOrValue<string> | null, newUnderlyingIsWETH?: null): UnderlyingIsWETHUpdatedEventFilter;
        UnderlyingIsWETHUpdated(user?: PromiseOrValue<string> | null, newUnderlyingIsWETH?: null): UnderlyingIsWETHUpdatedEventFilter;
        "Withdraw(address,uint256)"(user?: PromiseOrValue<string> | null, underlyingAmount?: null): WithdrawEventFilter;
        Withdraw(user?: PromiseOrValue<string> | null, underlyingAmount?: null): WithdrawEventFilter;
        "WithdrawalQueueIndexReplaced(address,uint256,address,address)"(user?: PromiseOrValue<string> | null, index?: null, replacedStrategy?: PromiseOrValue<string> | null, replacementStrategy?: PromiseOrValue<string> | null): WithdrawalQueueIndexReplacedEventFilter;
        WithdrawalQueueIndexReplaced(user?: PromiseOrValue<string> | null, index?: null, replacedStrategy?: PromiseOrValue<string> | null, replacementStrategy?: PromiseOrValue<string> | null): WithdrawalQueueIndexReplacedEventFilter;
        "WithdrawalQueueIndexReplacedWithTip(address,uint256,address,address)"(user?: PromiseOrValue<string> | null, index?: null, replacedStrategy?: PromiseOrValue<string> | null, previousTipStrategy?: PromiseOrValue<string> | null): WithdrawalQueueIndexReplacedWithTipEventFilter;
        WithdrawalQueueIndexReplacedWithTip(user?: PromiseOrValue<string> | null, index?: null, replacedStrategy?: PromiseOrValue<string> | null, previousTipStrategy?: PromiseOrValue<string> | null): WithdrawalQueueIndexReplacedWithTipEventFilter;
        "WithdrawalQueueIndexesSwapped(address,uint256,uint256,address,address)"(user?: PromiseOrValue<string> | null, index1?: null, index2?: null, newStrategy1?: PromiseOrValue<string> | null, newStrategy2?: PromiseOrValue<string> | null): WithdrawalQueueIndexesSwappedEventFilter;
        WithdrawalQueueIndexesSwapped(user?: PromiseOrValue<string> | null, index1?: null, index2?: null, newStrategy1?: PromiseOrValue<string> | null, newStrategy2?: PromiseOrValue<string> | null): WithdrawalQueueIndexesSwappedEventFilter;
        "WithdrawalQueuePopped(address,address)"(user?: PromiseOrValue<string> | null, poppedStrategy?: PromiseOrValue<string> | null): WithdrawalQueuePoppedEventFilter;
        WithdrawalQueuePopped(user?: PromiseOrValue<string> | null, poppedStrategy?: PromiseOrValue<string> | null): WithdrawalQueuePoppedEventFilter;
        "WithdrawalQueuePushed(address,address)"(user?: PromiseOrValue<string> | null, pushedStrategy?: PromiseOrValue<string> | null): WithdrawalQueuePushedEventFilter;
        WithdrawalQueuePushed(user?: PromiseOrValue<string> | null, pushedStrategy?: PromiseOrValue<string> | null): WithdrawalQueuePushedEventFilter;
        "WithdrawalQueueSet(address,address[])"(user?: PromiseOrValue<string> | null, replacedWithdrawalQueue?: null): WithdrawalQueueSetEventFilter;
        WithdrawalQueueSet(user?: PromiseOrValue<string> | null, replacedWithdrawalQueue?: null): WithdrawalQueueSetEventFilter;
    };
    estimateGas: {
        BASE_UNIT(overrides?: CallOverrides): Promise<BigNumber>;
        UNDERLYING(overrides?: CallOverrides): Promise<BigNumber>;
        addStrategy(strategy: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        allowance(owner: PromiseOrValue<string>, spender: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        approve(spender: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        balanceOf(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        balanceOfUnderlying(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        bulkAllow(users: PromiseOrValue<string>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        claimFees(rvTokenAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        cleanWithdrawalQueue(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        decimals(overrides?: CallOverrides): Promise<BigNumber>;
        decreaseAllowance(spender: PromiseOrValue<string>, subtractedValue: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        deposit(underlyingAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        depositIntoStrategy(strategy: PromiseOrValue<string>, underlyingAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        distrustStrategy(strategy: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        exchangeRate(overrides?: CallOverrides): Promise<BigNumber>;
        exchangeRateLock(lock: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
        feePercent(overrides?: CallOverrides): Promise<BigNumber>;
        getMaxTvl(overrides?: CallOverrides): Promise<BigNumber>;
        getStrategyData(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        getWithdrawalQueue(overrides?: CallOverrides): Promise<BigNumber>;
        harvest(strategies: PromiseOrValue<string>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        harvestDelay(overrides?: CallOverrides): Promise<BigNumber>;
        harvestWindow(overrides?: CallOverrides): Promise<BigNumber>;
        increaseAllowance(spender: PromiseOrValue<string>, addedValue: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        initialize(_UNDERLYING: PromiseOrValue<string>, _owner: PromiseOrValue<string>, _manager: PromiseOrValue<string>, _feePercent: PromiseOrValue<BigNumberish>, _harvestDelay: PromiseOrValue<BigNumberish>, _harvestWindow: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        isAllowed(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        isManager(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        isPublic(overrides?: CallOverrides): Promise<BigNumber>;
        lastHarvest(overrides?: CallOverrides): Promise<BigNumber>;
        lastHarvestWindowStart(overrides?: CallOverrides): Promise<BigNumber>;
        lockedProfit(overrides?: CallOverrides): Promise<BigNumber>;
        maxLockedLoss(overrides?: CallOverrides): Promise<BigNumber>;
        maxLockedProfit(overrides?: CallOverrides): Promise<BigNumber>;
        migrateStrategy(prevStrategy: PromiseOrValue<string>, newStrategy: PromiseOrValue<string>, queueIndex: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        name(overrides?: CallOverrides): Promise<BigNumber>;
        nextHarvestDelay(overrides?: CallOverrides): Promise<BigNumber>;
        owner(overrides?: CallOverrides): Promise<BigNumber>;
        popFromWithdrawalQueue(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        pushToWithdrawalQueue(strategy: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        pushToWithdrawalQueueValidated(strategy: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        redeem(rvTokenAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        renounceOwnership(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        replaceWithdrawalQueueIndex(index: PromiseOrValue<BigNumberish>, replacementStrategy: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        replaceWithdrawalQueueIndexWithTip(index: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        seizeStrategy(strategy: PromiseOrValue<string>, tokens: PromiseOrValue<string>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setAllowed(user: PromiseOrValue<string>, _isManager: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setFeePercent(newFeePercent: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setHarvestDelay(newHarvestDelay: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setHarvestWindow(newHarvestWindow: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setManager(user: PromiseOrValue<string>, _isManager: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setMaxTvl(maxTvl_: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setPublic(isPublic_: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setTargetFloatPercent(newTargetFloatPercent: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setUnderlyingIsWETH(newUnderlyingIsWETH: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setWithdrawalQueue(newQueue: PromiseOrValue<string>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        swapWithdrawalQueueIndexes(index1: PromiseOrValue<BigNumberish>, index2: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        symbol(overrides?: CallOverrides): Promise<BigNumber>;
        targetFloatPercent(overrides?: CallOverrides): Promise<BigNumber>;
        totalFloat(overrides?: CallOverrides): Promise<BigNumber>;
        totalHoldings(overrides?: CallOverrides): Promise<BigNumber>;
        totalHoldingsLock(lock: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
        totalStrategyHoldings(overrides?: CallOverrides): Promise<BigNumber>;
        totalSupply(overrides?: CallOverrides): Promise<BigNumber>;
        transfer(recipient: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        transferFrom(sender: PromiseOrValue<string>, recipient: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        trustStrategy(strategy: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        underlyingIsWETH(overrides?: CallOverrides): Promise<BigNumber>;
        updateStratTvl(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        version(overrides?: CallOverrides): Promise<BigNumber>;
        withdraw(underlyingAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        withdrawFromStrategy(strategy: PromiseOrValue<string>, underlyingAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        withdrawalQueue(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
    };
    populateTransaction: {
        BASE_UNIT(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        UNDERLYING(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        addStrategy(strategy: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        allowance(owner: PromiseOrValue<string>, spender: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        approve(spender: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        balanceOf(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        balanceOfUnderlying(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        bulkAllow(users: PromiseOrValue<string>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        claimFees(rvTokenAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        cleanWithdrawalQueue(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        decimals(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        decreaseAllowance(spender: PromiseOrValue<string>, subtractedValue: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        deposit(underlyingAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        depositIntoStrategy(strategy: PromiseOrValue<string>, underlyingAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        distrustStrategy(strategy: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        exchangeRate(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        exchangeRateLock(lock: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        feePercent(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getMaxTvl(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getStrategyData(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getWithdrawalQueue(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        harvest(strategies: PromiseOrValue<string>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        harvestDelay(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        harvestWindow(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        increaseAllowance(spender: PromiseOrValue<string>, addedValue: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        initialize(_UNDERLYING: PromiseOrValue<string>, _owner: PromiseOrValue<string>, _manager: PromiseOrValue<string>, _feePercent: PromiseOrValue<BigNumberish>, _harvestDelay: PromiseOrValue<BigNumberish>, _harvestWindow: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        isAllowed(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        isManager(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        isPublic(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        lastHarvest(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        lastHarvestWindowStart(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        lockedProfit(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        maxLockedLoss(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        maxLockedProfit(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        migrateStrategy(prevStrategy: PromiseOrValue<string>, newStrategy: PromiseOrValue<string>, queueIndex: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        name(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        nextHarvestDelay(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        popFromWithdrawalQueue(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        pushToWithdrawalQueue(strategy: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        pushToWithdrawalQueueValidated(strategy: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        redeem(rvTokenAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        renounceOwnership(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        replaceWithdrawalQueueIndex(index: PromiseOrValue<BigNumberish>, replacementStrategy: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        replaceWithdrawalQueueIndexWithTip(index: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        seizeStrategy(strategy: PromiseOrValue<string>, tokens: PromiseOrValue<string>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setAllowed(user: PromiseOrValue<string>, _isManager: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setFeePercent(newFeePercent: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setHarvestDelay(newHarvestDelay: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setHarvestWindow(newHarvestWindow: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setManager(user: PromiseOrValue<string>, _isManager: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setMaxTvl(maxTvl_: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setPublic(isPublic_: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setTargetFloatPercent(newTargetFloatPercent: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setUnderlyingIsWETH(newUnderlyingIsWETH: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setWithdrawalQueue(newQueue: PromiseOrValue<string>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        swapWithdrawalQueueIndexes(index1: PromiseOrValue<BigNumberish>, index2: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        symbol(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        targetFloatPercent(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        totalFloat(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        totalHoldings(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        totalHoldingsLock(lock: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        totalStrategyHoldings(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        totalSupply(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        transfer(recipient: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        transferFrom(sender: PromiseOrValue<string>, recipient: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        trustStrategy(strategy: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        underlyingIsWETH(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        updateStratTvl(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        version(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        withdraw(underlyingAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        withdrawFromStrategy(strategy: PromiseOrValue<string>, underlyingAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        withdrawalQueue(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
    };
}
