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 UnagiiV2VaultInterface extends utils.Interface {
    functions: {
        'initialize()': FunctionFragment;
        'migrate(address)': FunctionFragment;
        'setNextTimeLock(address)': FunctionFragment;
        'acceptTimeLock()': FunctionFragment;
        'setAdmin(address)': FunctionFragment;
        'setGuardian(address)': FunctionFragment;
        'setFundManager(address)': FunctionFragment;
        'setPause(bool)': FunctionFragment;
        'setMinReserve(uint256)': FunctionFragment;
        'setLockedProfitDegradation(uint256)': FunctionFragment;
        'setDepositLimit(uint256)': FunctionFragment;
        'setBlockDelay(uint256)': FunctionFragment;
        'setFeeOnTransfer(bool)': FunctionFragment;
        'setWhitelist(address,bool)': FunctionFragment;
        'totalAssets()': FunctionFragment;
        'calcLockedProfit()': FunctionFragment;
        'calcFreeFunds()': FunctionFragment;
        'calcSharesToMint(uint256)': FunctionFragment;
        'calcWithdraw(uint256)': FunctionFragment;
        'deposit(uint256,uint256)': FunctionFragment;
        'withdraw(uint256,uint256)': FunctionFragment;
        'calcMinReserve()': FunctionFragment;
        'calcMaxBorrow()': FunctionFragment;
        'borrow(uint256)': FunctionFragment;
        'repay(uint256)': FunctionFragment;
        'report(uint256,uint256)': FunctionFragment;
        'forceUpdateBalanceOfVault()': FunctionFragment;
        'skim()': FunctionFragment;
        'sweep(address)': FunctionFragment;
        'initialized()': FunctionFragment;
        'paused()': FunctionFragment;
        'token()': FunctionFragment;
        'uToken()': FunctionFragment;
        'fundManager()': FunctionFragment;
        'timeLock()': FunctionFragment;
        'nextTimeLock()': FunctionFragment;
        'guardian()': FunctionFragment;
        'admin()': FunctionFragment;
        'depositLimit()': FunctionFragment;
        'balanceOfVault()': FunctionFragment;
        'debt()': FunctionFragment;
        'minReserve()': FunctionFragment;
        'lastReport()': FunctionFragment;
        'lockedProfit()': FunctionFragment;
        'lockedProfitDegradation()': FunctionFragment;
        'blockDelay()': FunctionFragment;
        'whitelist(address)': FunctionFragment;
        'feeOnTransfer()': FunctionFragment;
        'oldVault()': FunctionFragment;
    };
    getFunction(nameOrSignatureOrTopic: 'initialize' | 'migrate' | 'setNextTimeLock' | 'acceptTimeLock' | 'setAdmin' | 'setGuardian' | 'setFundManager' | 'setPause' | 'setMinReserve' | 'setLockedProfitDegradation' | 'setDepositLimit' | 'setBlockDelay' | 'setFeeOnTransfer' | 'setWhitelist' | 'totalAssets' | 'calcLockedProfit' | 'calcFreeFunds' | 'calcSharesToMint' | 'calcWithdraw' | 'deposit' | 'withdraw' | 'calcMinReserve' | 'calcMaxBorrow' | 'borrow' | 'repay' | 'report' | 'forceUpdateBalanceOfVault' | 'skim' | 'sweep' | 'initialized' | 'paused' | 'token' | 'uToken' | 'fundManager' | 'timeLock' | 'nextTimeLock' | 'guardian' | 'admin' | 'depositLimit' | 'balanceOfVault' | 'debt' | 'minReserve' | 'lastReport' | 'lockedProfit' | 'lockedProfitDegradation' | 'blockDelay' | 'whitelist' | 'feeOnTransfer' | 'oldVault'): FunctionFragment;
    encodeFunctionData(functionFragment: 'initialize', values?: undefined): string;
    encodeFunctionData(functionFragment: 'migrate', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'setNextTimeLock', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'acceptTimeLock', values?: undefined): string;
    encodeFunctionData(functionFragment: 'setAdmin', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'setGuardian', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'setFundManager', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'setPause', values: [PromiseOrValue<boolean>]): string;
    encodeFunctionData(functionFragment: 'setMinReserve', values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'setLockedProfitDegradation', values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'setDepositLimit', values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'setBlockDelay', values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'setFeeOnTransfer', values: [PromiseOrValue<boolean>]): string;
    encodeFunctionData(functionFragment: 'setWhitelist', values: [PromiseOrValue<string>, PromiseOrValue<boolean>]): string;
    encodeFunctionData(functionFragment: 'totalAssets', values?: undefined): string;
    encodeFunctionData(functionFragment: 'calcLockedProfit', values?: undefined): string;
    encodeFunctionData(functionFragment: 'calcFreeFunds', values?: undefined): string;
    encodeFunctionData(functionFragment: 'calcSharesToMint', values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'calcWithdraw', values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'deposit', values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'withdraw', values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'calcMinReserve', values?: undefined): string;
    encodeFunctionData(functionFragment: 'calcMaxBorrow', values?: undefined): string;
    encodeFunctionData(functionFragment: 'borrow', values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'repay', values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'report', values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'forceUpdateBalanceOfVault', values?: undefined): string;
    encodeFunctionData(functionFragment: 'skim', values?: undefined): string;
    encodeFunctionData(functionFragment: 'sweep', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'initialized', values?: undefined): string;
    encodeFunctionData(functionFragment: 'paused', values?: undefined): string;
    encodeFunctionData(functionFragment: 'token', values?: undefined): string;
    encodeFunctionData(functionFragment: 'uToken', values?: undefined): string;
    encodeFunctionData(functionFragment: 'fundManager', values?: undefined): string;
    encodeFunctionData(functionFragment: 'timeLock', values?: undefined): string;
    encodeFunctionData(functionFragment: 'nextTimeLock', values?: undefined): string;
    encodeFunctionData(functionFragment: 'guardian', values?: undefined): string;
    encodeFunctionData(functionFragment: 'admin', values?: undefined): string;
    encodeFunctionData(functionFragment: 'depositLimit', values?: undefined): string;
    encodeFunctionData(functionFragment: 'balanceOfVault', values?: undefined): string;
    encodeFunctionData(functionFragment: 'debt', values?: undefined): string;
    encodeFunctionData(functionFragment: 'minReserve', values?: undefined): string;
    encodeFunctionData(functionFragment: 'lastReport', values?: undefined): string;
    encodeFunctionData(functionFragment: 'lockedProfit', values?: undefined): string;
    encodeFunctionData(functionFragment: 'lockedProfitDegradation', values?: undefined): string;
    encodeFunctionData(functionFragment: 'blockDelay', values?: undefined): string;
    encodeFunctionData(functionFragment: 'whitelist', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'feeOnTransfer', values?: undefined): string;
    encodeFunctionData(functionFragment: 'oldVault', values?: undefined): string;
    decodeFunctionResult(functionFragment: 'initialize', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'migrate', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'setNextTimeLock', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'acceptTimeLock', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'setAdmin', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'setGuardian', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'setFundManager', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'setPause', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'setMinReserve', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'setLockedProfitDegradation', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'setDepositLimit', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'setBlockDelay', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'setFeeOnTransfer', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'setWhitelist', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'totalAssets', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'calcLockedProfit', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'calcFreeFunds', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'calcSharesToMint', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'calcWithdraw', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'deposit', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'withdraw', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'calcMinReserve', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'calcMaxBorrow', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'borrow', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'repay', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'report', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'forceUpdateBalanceOfVault', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'skim', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'sweep', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'initialized', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'paused', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'token', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'uToken', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'fundManager', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'timeLock', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'nextTimeLock', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'guardian', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'admin', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'depositLimit', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'balanceOfVault', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'debt', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'minReserve', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'lastReport', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'lockedProfit', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'lockedProfitDegradation', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'blockDelay', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'whitelist', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'feeOnTransfer', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'oldVault', data: BytesLike): Result;
    events: {
        'Migrate(address,uint256,uint256,uint256)': EventFragment;
        'SetNextTimeLock(address)': EventFragment;
        'AcceptTimeLock(address)': EventFragment;
        'SetGuardian(address)': EventFragment;
        'SetAdmin(address)': EventFragment;
        'SetFundManager(address)': EventFragment;
        'SetPause(bool)': EventFragment;
        'SetWhitelist(address,bool)': EventFragment;
        'Deposit(address,uint256,uint256,uint256)': EventFragment;
        'Withdraw(address,uint256,uint256)': EventFragment;
        'Borrow(address,uint256,uint256)': EventFragment;
        'Repay(address,uint256,uint256)': EventFragment;
        'Report(address,uint256,uint256,uint256,uint256,uint256,uint256)': EventFragment;
        'ForceUpdateBalanceOfVault(uint256)': EventFragment;
    };
    getEvent(nameOrSignatureOrTopic: 'Migrate'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'SetNextTimeLock'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'AcceptTimeLock'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'SetGuardian'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'SetAdmin'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'SetFundManager'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'SetPause'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'SetWhitelist'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'Deposit'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'Withdraw'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'Borrow'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'Repay'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'Report'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'ForceUpdateBalanceOfVault'): EventFragment;
}
export interface MigrateEventObject {
    vault: string;
    balanceOfVault: BigNumber;
    debt: BigNumber;
    lockedProfit: BigNumber;
}
export declare type MigrateEvent = TypedEvent<[string, BigNumber, BigNumber, BigNumber], MigrateEventObject>;
export declare type MigrateEventFilter = TypedEventFilter<MigrateEvent>;
export interface SetNextTimeLockEventObject {
    nextTimeLock: string;
}
export declare type SetNextTimeLockEvent = TypedEvent<[string], SetNextTimeLockEventObject>;
export declare type SetNextTimeLockEventFilter = TypedEventFilter<SetNextTimeLockEvent>;
export interface AcceptTimeLockEventObject {
    timeLock: string;
}
export declare type AcceptTimeLockEvent = TypedEvent<[string], AcceptTimeLockEventObject>;
export declare type AcceptTimeLockEventFilter = TypedEventFilter<AcceptTimeLockEvent>;
export interface SetGuardianEventObject {
    guardian: string;
}
export declare type SetGuardianEvent = TypedEvent<[string], SetGuardianEventObject>;
export declare type SetGuardianEventFilter = TypedEventFilter<SetGuardianEvent>;
export interface SetAdminEventObject {
    admin: string;
}
export declare type SetAdminEvent = TypedEvent<[string], SetAdminEventObject>;
export declare type SetAdminEventFilter = TypedEventFilter<SetAdminEvent>;
export interface SetFundManagerEventObject {
    fundManager: string;
}
export declare type SetFundManagerEvent = TypedEvent<[string], SetFundManagerEventObject>;
export declare type SetFundManagerEventFilter = TypedEventFilter<SetFundManagerEvent>;
export interface SetPauseEventObject {
    paused: boolean;
}
export declare type SetPauseEvent = TypedEvent<[boolean], SetPauseEventObject>;
export declare type SetPauseEventFilter = TypedEventFilter<SetPauseEvent>;
export interface SetWhitelistEventObject {
    addr: string;
    approved: boolean;
}
export declare type SetWhitelistEvent = TypedEvent<[string, boolean], SetWhitelistEventObject>;
export declare type SetWhitelistEventFilter = TypedEventFilter<SetWhitelistEvent>;
export interface DepositEventObject {
    sender: string;
    amount: BigNumber;
    diff: BigNumber;
    shares: BigNumber;
}
export declare type DepositEvent = TypedEvent<[string, BigNumber, BigNumber, BigNumber], DepositEventObject>;
export declare type DepositEventFilter = TypedEventFilter<DepositEvent>;
export interface WithdrawEventObject {
    owner: string;
    shares: BigNumber;
    amount: BigNumber;
}
export declare type WithdrawEvent = TypedEvent<[string, BigNumber, BigNumber], WithdrawEventObject>;
export declare type WithdrawEventFilter = TypedEventFilter<WithdrawEvent>;
export interface BorrowEventObject {
    fundManager: string;
    amount: BigNumber;
    borrowed: BigNumber;
}
export declare type BorrowEvent = TypedEvent<[string, BigNumber, BigNumber], BorrowEventObject>;
export declare type BorrowEventFilter = TypedEventFilter<BorrowEvent>;
export interface RepayEventObject {
    fundManager: string;
    amount: BigNumber;
    repaid: BigNumber;
}
export declare type RepayEvent = TypedEvent<[string, BigNumber, BigNumber], RepayEventObject>;
export declare type RepayEventFilter = TypedEventFilter<RepayEvent>;
export interface ReportEventObject {
    fundManager: string;
    balanceOfVault: BigNumber;
    debt: BigNumber;
    gain: BigNumber;
    loss: BigNumber;
    diff: BigNumber;
    lockedProfit: BigNumber;
}
export declare type ReportEvent = TypedEvent<[
    string,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber
], ReportEventObject>;
export declare type ReportEventFilter = TypedEventFilter<ReportEvent>;
export interface ForceUpdateBalanceOfVaultEventObject {
    balanceOfVault: BigNumber;
}
export declare type ForceUpdateBalanceOfVaultEvent = TypedEvent<[BigNumber], ForceUpdateBalanceOfVaultEventObject>;
export declare type ForceUpdateBalanceOfVaultEventFilter = TypedEventFilter<ForceUpdateBalanceOfVaultEvent>;
export interface UnagiiV2Vault extends BaseContract {
    connect(signerOrProvider: Signer | Provider | string): this;
    attach(addressOrName: string): this;
    deployed(): Promise<this>;
    interface: UnagiiV2VaultInterface;
    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: {
        initialize(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        migrate(vault: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setNextTimeLock(nextTimeLock: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        acceptTimeLock(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setAdmin(admin: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setGuardian(guardian: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setFundManager(fundManager: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setPause(paused: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setMinReserve(minReserve: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setLockedProfitDegradation(degradation: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setDepositLimit(limit: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setBlockDelay(delay: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setFeeOnTransfer(feeOnTransfer: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setWhitelist(addr: PromiseOrValue<string>, approved: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        totalAssets(overrides?: CallOverrides): Promise<[BigNumber]>;
        calcLockedProfit(overrides?: CallOverrides): Promise<[BigNumber]>;
        calcFreeFunds(overrides?: CallOverrides): Promise<[BigNumber]>;
        calcSharesToMint(amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[BigNumber]>;
        calcWithdraw(shares: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[BigNumber]>;
        deposit(amount: PromiseOrValue<BigNumberish>, _min: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        withdraw(shares: PromiseOrValue<BigNumberish>, _min: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        calcMinReserve(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        calcMaxBorrow(overrides?: CallOverrides): Promise<[BigNumber]>;
        borrow(amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        repay(amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        report(gain: PromiseOrValue<BigNumberish>, loss: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        forceUpdateBalanceOfVault(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        skim(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        sweep(token: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        initialized(overrides?: CallOverrides): Promise<[boolean]>;
        paused(overrides?: CallOverrides): Promise<[boolean]>;
        token(overrides?: CallOverrides): Promise<[string]>;
        uToken(overrides?: CallOverrides): Promise<[string]>;
        fundManager(overrides?: CallOverrides): Promise<[string]>;
        timeLock(overrides?: CallOverrides): Promise<[string]>;
        nextTimeLock(overrides?: CallOverrides): Promise<[string]>;
        guardian(overrides?: CallOverrides): Promise<[string]>;
        admin(overrides?: CallOverrides): Promise<[string]>;
        depositLimit(overrides?: CallOverrides): Promise<[BigNumber]>;
        balanceOfVault(overrides?: CallOverrides): Promise<[BigNumber]>;
        debt(overrides?: CallOverrides): Promise<[BigNumber]>;
        minReserve(overrides?: CallOverrides): Promise<[BigNumber]>;
        lastReport(overrides?: CallOverrides): Promise<[BigNumber]>;
        lockedProfit(overrides?: CallOverrides): Promise<[BigNumber]>;
        lockedProfitDegradation(overrides?: CallOverrides): Promise<[BigNumber]>;
        blockDelay(overrides?: CallOverrides): Promise<[BigNumber]>;
        whitelist(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>;
        feeOnTransfer(overrides?: CallOverrides): Promise<[boolean]>;
        oldVault(overrides?: CallOverrides): Promise<[string]>;
    };
    initialize(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    migrate(vault: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setNextTimeLock(nextTimeLock: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    acceptTimeLock(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setAdmin(admin: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setGuardian(guardian: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setFundManager(fundManager: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setPause(paused: PromiseOrValue<boolean>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setMinReserve(minReserve: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setLockedProfitDegradation(degradation: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setDepositLimit(limit: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setBlockDelay(delay: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setFeeOnTransfer(feeOnTransfer: PromiseOrValue<boolean>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setWhitelist(addr: PromiseOrValue<string>, approved: PromiseOrValue<boolean>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    totalAssets(overrides?: CallOverrides): Promise<BigNumber>;
    calcLockedProfit(overrides?: CallOverrides): Promise<BigNumber>;
    calcFreeFunds(overrides?: CallOverrides): Promise<BigNumber>;
    calcSharesToMint(amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
    calcWithdraw(shares: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
    deposit(amount: PromiseOrValue<BigNumberish>, _min: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    withdraw(shares: PromiseOrValue<BigNumberish>, _min: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    calcMinReserve(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    calcMaxBorrow(overrides?: CallOverrides): Promise<BigNumber>;
    borrow(amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    repay(amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    report(gain: PromiseOrValue<BigNumberish>, loss: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    forceUpdateBalanceOfVault(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    skim(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    sweep(token: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    initialized(overrides?: CallOverrides): Promise<boolean>;
    paused(overrides?: CallOverrides): Promise<boolean>;
    token(overrides?: CallOverrides): Promise<string>;
    uToken(overrides?: CallOverrides): Promise<string>;
    fundManager(overrides?: CallOverrides): Promise<string>;
    timeLock(overrides?: CallOverrides): Promise<string>;
    nextTimeLock(overrides?: CallOverrides): Promise<string>;
    guardian(overrides?: CallOverrides): Promise<string>;
    admin(overrides?: CallOverrides): Promise<string>;
    depositLimit(overrides?: CallOverrides): Promise<BigNumber>;
    balanceOfVault(overrides?: CallOverrides): Promise<BigNumber>;
    debt(overrides?: CallOverrides): Promise<BigNumber>;
    minReserve(overrides?: CallOverrides): Promise<BigNumber>;
    lastReport(overrides?: CallOverrides): Promise<BigNumber>;
    lockedProfit(overrides?: CallOverrides): Promise<BigNumber>;
    lockedProfitDegradation(overrides?: CallOverrides): Promise<BigNumber>;
    blockDelay(overrides?: CallOverrides): Promise<BigNumber>;
    whitelist(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
    feeOnTransfer(overrides?: CallOverrides): Promise<boolean>;
    oldVault(overrides?: CallOverrides): Promise<string>;
    callStatic: {
        initialize(overrides?: CallOverrides): Promise<void>;
        migrate(vault: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        setNextTimeLock(nextTimeLock: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        acceptTimeLock(overrides?: CallOverrides): Promise<void>;
        setAdmin(admin: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        setGuardian(guardian: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        setFundManager(fundManager: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        setPause(paused: PromiseOrValue<boolean>, overrides?: CallOverrides): Promise<void>;
        setMinReserve(minReserve: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        setLockedProfitDegradation(degradation: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        setDepositLimit(limit: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        setBlockDelay(delay: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        setFeeOnTransfer(feeOnTransfer: PromiseOrValue<boolean>, overrides?: CallOverrides): Promise<void>;
        setWhitelist(addr: PromiseOrValue<string>, approved: PromiseOrValue<boolean>, overrides?: CallOverrides): Promise<void>;
        totalAssets(overrides?: CallOverrides): Promise<BigNumber>;
        calcLockedProfit(overrides?: CallOverrides): Promise<BigNumber>;
        calcFreeFunds(overrides?: CallOverrides): Promise<BigNumber>;
        calcSharesToMint(amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
        calcWithdraw(shares: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
        deposit(amount: PromiseOrValue<BigNumberish>, _min: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
        withdraw(shares: PromiseOrValue<BigNumberish>, _min: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
        calcMinReserve(overrides?: CallOverrides): Promise<BigNumber>;
        calcMaxBorrow(overrides?: CallOverrides): Promise<BigNumber>;
        borrow(amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
        repay(amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
        report(gain: PromiseOrValue<BigNumberish>, loss: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        forceUpdateBalanceOfVault(overrides?: CallOverrides): Promise<void>;
        skim(overrides?: CallOverrides): Promise<void>;
        sweep(token: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        initialized(overrides?: CallOverrides): Promise<boolean>;
        paused(overrides?: CallOverrides): Promise<boolean>;
        token(overrides?: CallOverrides): Promise<string>;
        uToken(overrides?: CallOverrides): Promise<string>;
        fundManager(overrides?: CallOverrides): Promise<string>;
        timeLock(overrides?: CallOverrides): Promise<string>;
        nextTimeLock(overrides?: CallOverrides): Promise<string>;
        guardian(overrides?: CallOverrides): Promise<string>;
        admin(overrides?: CallOverrides): Promise<string>;
        depositLimit(overrides?: CallOverrides): Promise<BigNumber>;
        balanceOfVault(overrides?: CallOverrides): Promise<BigNumber>;
        debt(overrides?: CallOverrides): Promise<BigNumber>;
        minReserve(overrides?: CallOverrides): Promise<BigNumber>;
        lastReport(overrides?: CallOverrides): Promise<BigNumber>;
        lockedProfit(overrides?: CallOverrides): Promise<BigNumber>;
        lockedProfitDegradation(overrides?: CallOverrides): Promise<BigNumber>;
        blockDelay(overrides?: CallOverrides): Promise<BigNumber>;
        whitelist(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
        feeOnTransfer(overrides?: CallOverrides): Promise<boolean>;
        oldVault(overrides?: CallOverrides): Promise<string>;
    };
    filters: {
        'Migrate(address,uint256,uint256,uint256)'(vault?: null, balanceOfVault?: null, debt?: null, lockedProfit?: null): MigrateEventFilter;
        Migrate(vault?: null, balanceOfVault?: null, debt?: null, lockedProfit?: null): MigrateEventFilter;
        'SetNextTimeLock(address)'(nextTimeLock?: null): SetNextTimeLockEventFilter;
        SetNextTimeLock(nextTimeLock?: null): SetNextTimeLockEventFilter;
        'AcceptTimeLock(address)'(timeLock?: null): AcceptTimeLockEventFilter;
        AcceptTimeLock(timeLock?: null): AcceptTimeLockEventFilter;
        'SetGuardian(address)'(guardian?: null): SetGuardianEventFilter;
        SetGuardian(guardian?: null): SetGuardianEventFilter;
        'SetAdmin(address)'(admin?: null): SetAdminEventFilter;
        SetAdmin(admin?: null): SetAdminEventFilter;
        'SetFundManager(address)'(fundManager?: null): SetFundManagerEventFilter;
        SetFundManager(fundManager?: null): SetFundManagerEventFilter;
        'SetPause(bool)'(paused?: null): SetPauseEventFilter;
        SetPause(paused?: null): SetPauseEventFilter;
        'SetWhitelist(address,bool)'(addr?: PromiseOrValue<string> | null, approved?: null): SetWhitelistEventFilter;
        SetWhitelist(addr?: PromiseOrValue<string> | null, approved?: null): SetWhitelistEventFilter;
        'Deposit(address,uint256,uint256,uint256)'(sender?: PromiseOrValue<string> | null, amount?: null, diff?: null, shares?: null): DepositEventFilter;
        Deposit(sender?: PromiseOrValue<string> | null, amount?: null, diff?: null, shares?: null): DepositEventFilter;
        'Withdraw(address,uint256,uint256)'(owner?: PromiseOrValue<string> | null, shares?: null, amount?: null): WithdrawEventFilter;
        Withdraw(owner?: PromiseOrValue<string> | null, shares?: null, amount?: null): WithdrawEventFilter;
        'Borrow(address,uint256,uint256)'(fundManager?: PromiseOrValue<string> | null, amount?: null, borrowed?: null): BorrowEventFilter;
        Borrow(fundManager?: PromiseOrValue<string> | null, amount?: null, borrowed?: null): BorrowEventFilter;
        'Repay(address,uint256,uint256)'(fundManager?: PromiseOrValue<string> | null, amount?: null, repaid?: null): RepayEventFilter;
        Repay(fundManager?: PromiseOrValue<string> | null, amount?: null, repaid?: null): RepayEventFilter;
        'Report(address,uint256,uint256,uint256,uint256,uint256,uint256)'(fundManager?: PromiseOrValue<string> | null, balanceOfVault?: null, debt?: null, gain?: null, loss?: null, diff?: null, lockedProfit?: null): ReportEventFilter;
        Report(fundManager?: PromiseOrValue<string> | null, balanceOfVault?: null, debt?: null, gain?: null, loss?: null, diff?: null, lockedProfit?: null): ReportEventFilter;
        'ForceUpdateBalanceOfVault(uint256)'(balanceOfVault?: null): ForceUpdateBalanceOfVaultEventFilter;
        ForceUpdateBalanceOfVault(balanceOfVault?: null): ForceUpdateBalanceOfVaultEventFilter;
    };
    estimateGas: {
        initialize(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        migrate(vault: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setNextTimeLock(nextTimeLock: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        acceptTimeLock(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setAdmin(admin: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setGuardian(guardian: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setFundManager(fundManager: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setPause(paused: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setMinReserve(minReserve: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setLockedProfitDegradation(degradation: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setDepositLimit(limit: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setBlockDelay(delay: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setFeeOnTransfer(feeOnTransfer: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setWhitelist(addr: PromiseOrValue<string>, approved: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        totalAssets(overrides?: CallOverrides): Promise<BigNumber>;
        calcLockedProfit(overrides?: CallOverrides): Promise<BigNumber>;
        calcFreeFunds(overrides?: CallOverrides): Promise<BigNumber>;
        calcSharesToMint(amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
        calcWithdraw(shares: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
        deposit(amount: PromiseOrValue<BigNumberish>, _min: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        withdraw(shares: PromiseOrValue<BigNumberish>, _min: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        calcMinReserve(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        calcMaxBorrow(overrides?: CallOverrides): Promise<BigNumber>;
        borrow(amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        repay(amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        report(gain: PromiseOrValue<BigNumberish>, loss: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        forceUpdateBalanceOfVault(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        skim(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        sweep(token: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        initialized(overrides?: CallOverrides): Promise<BigNumber>;
        paused(overrides?: CallOverrides): Promise<BigNumber>;
        token(overrides?: CallOverrides): Promise<BigNumber>;
        uToken(overrides?: CallOverrides): Promise<BigNumber>;
        fundManager(overrides?: CallOverrides): Promise<BigNumber>;
        timeLock(overrides?: CallOverrides): Promise<BigNumber>;
        nextTimeLock(overrides?: CallOverrides): Promise<BigNumber>;
        guardian(overrides?: CallOverrides): Promise<BigNumber>;
        admin(overrides?: CallOverrides): Promise<BigNumber>;
        depositLimit(overrides?: CallOverrides): Promise<BigNumber>;
        balanceOfVault(overrides?: CallOverrides): Promise<BigNumber>;
        debt(overrides?: CallOverrides): Promise<BigNumber>;
        minReserve(overrides?: CallOverrides): Promise<BigNumber>;
        lastReport(overrides?: CallOverrides): Promise<BigNumber>;
        lockedProfit(overrides?: CallOverrides): Promise<BigNumber>;
        lockedProfitDegradation(overrides?: CallOverrides): Promise<BigNumber>;
        blockDelay(overrides?: CallOverrides): Promise<BigNumber>;
        whitelist(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        feeOnTransfer(overrides?: CallOverrides): Promise<BigNumber>;
        oldVault(overrides?: CallOverrides): Promise<BigNumber>;
    };
    populateTransaction: {
        initialize(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        migrate(vault: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setNextTimeLock(nextTimeLock: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        acceptTimeLock(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setAdmin(admin: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setGuardian(guardian: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setFundManager(fundManager: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setPause(paused: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setMinReserve(minReserve: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setLockedProfitDegradation(degradation: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setDepositLimit(limit: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setBlockDelay(delay: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setFeeOnTransfer(feeOnTransfer: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setWhitelist(addr: PromiseOrValue<string>, approved: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        totalAssets(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        calcLockedProfit(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        calcFreeFunds(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        calcSharesToMint(amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        calcWithdraw(shares: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        deposit(amount: PromiseOrValue<BigNumberish>, _min: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        withdraw(shares: PromiseOrValue<BigNumberish>, _min: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        calcMinReserve(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        calcMaxBorrow(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        borrow(amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        repay(amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        report(gain: PromiseOrValue<BigNumberish>, loss: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        forceUpdateBalanceOfVault(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        skim(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        sweep(token: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        initialized(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        paused(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        token(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        uToken(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        fundManager(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        timeLock(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        nextTimeLock(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        guardian(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        admin(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        depositLimit(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        balanceOfVault(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        debt(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        minReserve(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        lastReport(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        lockedProfit(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        lockedProfitDegradation(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        blockDelay(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        whitelist(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        feeOnTransfer(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        oldVault(overrides?: CallOverrides): Promise<PopulatedTransaction>;
    };
}
