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 } from "./common";
export type AaveV3StrategyInitializerParamsStruct = {
    aaveToken: string;
    strategyDelegateFeeRate: BigNumberish;
    strategyProtocolFeeRate: BigNumberish;
    referralCode: BigNumberish;
    useVirtualUnderlyingBalance: boolean;
    strategyMetadata: string;
};
export type AaveV3StrategyInitializerParamsStructOutput = [
    string,
    number,
    number,
    number,
    boolean,
    string
] & {
    aaveToken: string;
    strategyDelegateFeeRate: number;
    strategyProtocolFeeRate: number;
    referralCode: number;
    useVirtualUnderlyingBalance: boolean;
    strategyMetadata: string;
};
export interface MapleAaveV3StrategyAbiInterface extends utils.Interface {
    functions: {
        "HUNDRED_PERCENT()": FunctionFragment;
        "STRATEGY_TYPE()": FunctionFragment;
        "aavePool()": FunctionFragment;
        "aaveToken()": FunctionFragment;
        "assetsUnderManagement()": FunctionFragment;
        "availableToWithdraw()": FunctionFragment;
        "claimRewards(address[],uint256,address)": FunctionFragment;
        "factory()": FunctionFragment;
        "fundUnderlyingStrategy(uint256,bytes)": FunctionFragment;
        "fundsAsset()": FunctionFragment;
        "globals()": FunctionFragment;
        "impair(uint256)": FunctionFragment;
        "impairedAssets()": FunctionFragment;
        "implementation()": FunctionFragment;
        "isLossRecognized()": FunctionFragment;
        "lastRecordedTotalAssets()": FunctionFragment;
        "mapleTreasury()": FunctionFragment;
        "migrate(address,bytes)": FunctionFragment;
        "multicall(bytes[])": FunctionFragment;
        "recognizeLoss()": FunctionFragment;
        "recoverPosition()": FunctionFragment;
        "referralCode()": FunctionFragment;
        "removeImpairment(uint256)": FunctionFragment;
        "securityAdmin()": FunctionFragment;
        "setImplementation(address)": FunctionFragment;
        "setMetadata(string)": FunctionFragment;
        "setReferralCode(uint16)": FunctionFragment;
        "setStrategyDelegateFeeRate(uint32)": FunctionFragment;
        "setStrategyProtocolFeeRate(uint32)": FunctionFragment;
        "setUseVirtualUnderlyingBalance(bool)": FunctionFragment;
        "strategyDelegate()": FunctionFragment;
        "strategyDelegateFeeRate()": FunctionFragment;
        "strategyManager()": FunctionFragment;
        "strategyMetadata()": FunctionFragment;
        "strategyProtocolFeeRate()": FunctionFragment;
        "unrealizedLosses()": FunctionFragment;
        "upgrade(uint256,bytes)": FunctionFragment;
        "useVirtualUnderlyingBalance()": FunctionFragment;
        "withdrawFromUnderlyingStrategy(address,uint256,bytes)": FunctionFragment;
    };
    getFunction(nameOrSignatureOrTopic: "HUNDRED_PERCENT" | "STRATEGY_TYPE" | "aavePool" | "aaveToken" | "assetsUnderManagement" | "availableToWithdraw" | "claimRewards" | "factory" | "fundUnderlyingStrategy" | "fundsAsset" | "globals" | "impair" | "impairedAssets" | "implementation" | "isLossRecognized" | "lastRecordedTotalAssets" | "mapleTreasury" | "migrate" | "multicall" | "recognizeLoss" | "recoverPosition" | "referralCode" | "removeImpairment" | "securityAdmin" | "setImplementation" | "setMetadata" | "setReferralCode" | "setStrategyDelegateFeeRate" | "setStrategyProtocolFeeRate" | "setUseVirtualUnderlyingBalance" | "strategyDelegate" | "strategyDelegateFeeRate" | "strategyManager" | "strategyMetadata" | "strategyProtocolFeeRate" | "unrealizedLosses" | "upgrade" | "useVirtualUnderlyingBalance" | "withdrawFromUnderlyingStrategy"): FunctionFragment;
    encodeFunctionData(functionFragment: "HUNDRED_PERCENT", values?: undefined): string;
    encodeFunctionData(functionFragment: "STRATEGY_TYPE", values?: undefined): string;
    encodeFunctionData(functionFragment: "aavePool", values?: undefined): string;
    encodeFunctionData(functionFragment: "aaveToken", values?: undefined): string;
    encodeFunctionData(functionFragment: "assetsUnderManagement", values?: undefined): string;
    encodeFunctionData(functionFragment: "availableToWithdraw", values?: undefined): string;
    encodeFunctionData(functionFragment: "claimRewards", values: [string[], BigNumberish, string]): string;
    encodeFunctionData(functionFragment: "factory", values?: undefined): string;
    encodeFunctionData(functionFragment: "fundUnderlyingStrategy", values: [BigNumberish, BytesLike]): string;
    encodeFunctionData(functionFragment: "fundsAsset", values?: undefined): string;
    encodeFunctionData(functionFragment: "globals", values?: undefined): string;
    encodeFunctionData(functionFragment: "impair", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "impairedAssets", values?: undefined): string;
    encodeFunctionData(functionFragment: "implementation", values?: undefined): string;
    encodeFunctionData(functionFragment: "isLossRecognized", values?: undefined): string;
    encodeFunctionData(functionFragment: "lastRecordedTotalAssets", values?: undefined): string;
    encodeFunctionData(functionFragment: "mapleTreasury", values?: undefined): string;
    encodeFunctionData(functionFragment: "migrate", values: [string, BytesLike]): string;
    encodeFunctionData(functionFragment: "multicall", values: [BytesLike[]]): string;
    encodeFunctionData(functionFragment: "recognizeLoss", values?: undefined): string;
    encodeFunctionData(functionFragment: "recoverPosition", values?: undefined): string;
    encodeFunctionData(functionFragment: "referralCode", values?: undefined): string;
    encodeFunctionData(functionFragment: "removeImpairment", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "securityAdmin", values?: undefined): string;
    encodeFunctionData(functionFragment: "setImplementation", values: [string]): string;
    encodeFunctionData(functionFragment: "setMetadata", values: [string]): string;
    encodeFunctionData(functionFragment: "setReferralCode", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "setStrategyDelegateFeeRate", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "setStrategyProtocolFeeRate", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "setUseVirtualUnderlyingBalance", values: [boolean]): string;
    encodeFunctionData(functionFragment: "strategyDelegate", values?: undefined): string;
    encodeFunctionData(functionFragment: "strategyDelegateFeeRate", values?: undefined): string;
    encodeFunctionData(functionFragment: "strategyManager", values?: undefined): string;
    encodeFunctionData(functionFragment: "strategyMetadata", values?: undefined): string;
    encodeFunctionData(functionFragment: "strategyProtocolFeeRate", values?: undefined): string;
    encodeFunctionData(functionFragment: "unrealizedLosses", values?: undefined): string;
    encodeFunctionData(functionFragment: "upgrade", values: [BigNumberish, BytesLike]): string;
    encodeFunctionData(functionFragment: "useVirtualUnderlyingBalance", values?: undefined): string;
    encodeFunctionData(functionFragment: "withdrawFromUnderlyingStrategy", values: [string, BigNumberish, BytesLike]): string;
    decodeFunctionResult(functionFragment: "HUNDRED_PERCENT", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "STRATEGY_TYPE", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "aavePool", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "aaveToken", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "assetsUnderManagement", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "availableToWithdraw", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "claimRewards", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "factory", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "fundUnderlyingStrategy", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "fundsAsset", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "globals", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "impair", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "impairedAssets", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "implementation", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "isLossRecognized", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "lastRecordedTotalAssets", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "mapleTreasury", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "migrate", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "multicall", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "recognizeLoss", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "recoverPosition", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "referralCode", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "removeImpairment", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "securityAdmin", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setImplementation", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setMetadata", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setReferralCode", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setStrategyDelegateFeeRate", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setStrategyProtocolFeeRate", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setUseVirtualUnderlyingBalance", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "strategyDelegate", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "strategyDelegateFeeRate", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "strategyManager", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "strategyMetadata", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "strategyProtocolFeeRate", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "unrealizedLosses", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "upgrade", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "useVirtualUnderlyingBalance", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "withdrawFromUnderlyingStrategy", data: BytesLike): Result;
    events: {
        "Initialized(address,(address,uint32,uint32,uint16,bool,string))": EventFragment;
        "Impaired(uint256)": EventFragment;
        "ImpairmentRemoved(uint256)": EventFragment;
        "LossRecognized()": EventFragment;
        "PositionRecovered(uint256)": EventFragment;
        "ReferralCodeSet(uint16)": EventFragment;
        "RewardsClaimed(address,uint256)": EventFragment;
        "StrategyDelegateFeeRateSet(uint32)": EventFragment;
        "StrategyFeesCollected(uint256,uint256)": EventFragment;
        "StrategyFunded(address,uint256,uint256)": EventFragment;
        "StrategyMetadataSet(string)": EventFragment;
        "StrategyProtocolFeeRateSet(uint32)": EventFragment;
        "StrategyWithdrawal(address,uint256)": EventFragment;
        "Upgraded(uint256,bytes)": EventFragment;
        "UseVirtualUnderlyingBalanceSet(bool)": EventFragment;
    };
    getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Impaired"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "ImpairmentRemoved"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "LossRecognized"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "PositionRecovered"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "ReferralCodeSet"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "RewardsClaimed"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "StrategyDelegateFeeRateSet"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "StrategyFeesCollected"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "StrategyFunded"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "StrategyMetadataSet"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "StrategyProtocolFeeRateSet"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "StrategyWithdrawal"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Upgraded"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "UseVirtualUnderlyingBalanceSet"): EventFragment;
}
export interface InitializedEventObject {
    strategyManager: string;
    params: AaveV3StrategyInitializerParamsStructOutput;
}
export type InitializedEvent = TypedEvent<[
    string,
    AaveV3StrategyInitializerParamsStructOutput
], InitializedEventObject>;
export type InitializedEventFilter = TypedEventFilter<InitializedEvent>;
export interface ImpairedEventObject {
    assets: BigNumber;
}
export type ImpairedEvent = TypedEvent<[BigNumber], ImpairedEventObject>;
export type ImpairedEventFilter = TypedEventFilter<ImpairedEvent>;
export interface ImpairmentRemovedEventObject {
    assets: BigNumber;
}
export type ImpairmentRemovedEvent = TypedEvent<[
    BigNumber
], ImpairmentRemovedEventObject>;
export type ImpairmentRemovedEventFilter = TypedEventFilter<ImpairmentRemovedEvent>;
export interface LossRecognizedEventObject {
}
export type LossRecognizedEvent = TypedEvent<[], LossRecognizedEventObject>;
export type LossRecognizedEventFilter = TypedEventFilter<LossRecognizedEvent>;
export interface PositionRecoveredEventObject {
    shares: BigNumber;
}
export type PositionRecoveredEvent = TypedEvent<[
    BigNumber
], PositionRecoveredEventObject>;
export type PositionRecoveredEventFilter = TypedEventFilter<PositionRecoveredEvent>;
export interface ReferralCodeSetEventObject {
    referralCode: number;
}
export type ReferralCodeSetEvent = TypedEvent<[
    number
], ReferralCodeSetEventObject>;
export type ReferralCodeSetEventFilter = TypedEventFilter<ReferralCodeSetEvent>;
export interface RewardsClaimedEventObject {
    rewardToken: string;
    amount: BigNumber;
}
export type RewardsClaimedEvent = TypedEvent<[
    string,
    BigNumber
], RewardsClaimedEventObject>;
export type RewardsClaimedEventFilter = TypedEventFilter<RewardsClaimedEvent>;
export interface StrategyDelegateFeeRateSetEventObject {
    strategyDelegateFeeRate: number;
}
export type StrategyDelegateFeeRateSetEvent = TypedEvent<[
    number
], StrategyDelegateFeeRateSetEventObject>;
export type StrategyDelegateFeeRateSetEventFilter = TypedEventFilter<StrategyDelegateFeeRateSetEvent>;
export interface StrategyFeesCollectedEventObject {
    delegateFee: BigNumber;
    protocolFee: BigNumber;
}
export type StrategyFeesCollectedEvent = TypedEvent<[
    BigNumber,
    BigNumber
], StrategyFeesCollectedEventObject>;
export type StrategyFeesCollectedEventFilter = TypedEventFilter<StrategyFeesCollectedEvent>;
export interface StrategyFundedEventObject {
    strategyManager: string;
    assetsIn: BigNumber;
    deployedAssets: BigNumber;
}
export type StrategyFundedEvent = TypedEvent<[
    string,
    BigNumber,
    BigNumber
], StrategyFundedEventObject>;
export type StrategyFundedEventFilter = TypedEventFilter<StrategyFundedEvent>;
export interface StrategyMetadataSetEventObject {
    strategyMetadata: string;
}
export type StrategyMetadataSetEvent = TypedEvent<[
    string
], StrategyMetadataSetEventObject>;
export type StrategyMetadataSetEventFilter = TypedEventFilter<StrategyMetadataSetEvent>;
export interface StrategyProtocolFeeRateSetEventObject {
    strategyProtocolFeeRate: number;
}
export type StrategyProtocolFeeRateSetEvent = TypedEvent<[
    number
], StrategyProtocolFeeRateSetEventObject>;
export type StrategyProtocolFeeRateSetEventFilter = TypedEventFilter<StrategyProtocolFeeRateSetEvent>;
export interface StrategyWithdrawalEventObject {
    destination: string;
    assetsOut: BigNumber;
}
export type StrategyWithdrawalEvent = TypedEvent<[
    string,
    BigNumber
], StrategyWithdrawalEventObject>;
export type StrategyWithdrawalEventFilter = TypedEventFilter<StrategyWithdrawalEvent>;
export interface UpgradedEventObject {
    toVersion_: BigNumber;
    arguments_: string;
}
export type UpgradedEvent = TypedEvent<[
    BigNumber,
    string
], UpgradedEventObject>;
export type UpgradedEventFilter = TypedEventFilter<UpgradedEvent>;
export interface UseVirtualUnderlyingBalanceSetEventObject {
    useVirtualUnderlyingBalance: boolean;
}
export type UseVirtualUnderlyingBalanceSetEvent = TypedEvent<[
    boolean
], UseVirtualUnderlyingBalanceSetEventObject>;
export type UseVirtualUnderlyingBalanceSetEventFilter = TypedEventFilter<UseVirtualUnderlyingBalanceSetEvent>;
export interface MapleAaveV3StrategyAbi extends BaseContract {
    connect(signerOrProvider: Signer | Provider | string): this;
    attach(addressOrName: string): this;
    deployed(): Promise<this>;
    interface: MapleAaveV3StrategyAbiInterface;
    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: {
        HUNDRED_PERCENT(overrides?: CallOverrides): Promise<[BigNumber]>;
        STRATEGY_TYPE(overrides?: CallOverrides): Promise<[string]>;
        aavePool(overrides?: CallOverrides): Promise<[string]>;
        aaveToken(overrides?: CallOverrides): Promise<[string]>;
        assetsUnderManagement(overrides?: CallOverrides): Promise<[BigNumber] & {
            assetsUnderManagement_: BigNumber;
        }>;
        availableToWithdraw(overrides?: CallOverrides): Promise<[BigNumber] & {
            availableToWithdraw_: BigNumber;
        }>;
        claimRewards(assets_: string[], amount_: BigNumberish, rewardToken_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        factory(overrides?: CallOverrides): Promise<[string] & {
            factory_: string;
        }>;
        fundUnderlyingStrategy(assetsIn_: BigNumberish, arg1: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        fundsAsset(overrides?: CallOverrides): Promise<[string]>;
        globals(overrides?: CallOverrides): Promise<[string] & {
            globals_: string;
        }>;
        impair(assets_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        impairedAssets(overrides?: CallOverrides): Promise<[BigNumber]>;
        implementation(overrides?: CallOverrides): Promise<[string] & {
            implementation_: string;
        }>;
        isLossRecognized(overrides?: CallOverrides): Promise<[boolean]>;
        lastRecordedTotalAssets(overrides?: CallOverrides): Promise<[BigNumber]>;
        mapleTreasury(overrides?: CallOverrides): Promise<[string] & {
            mapleTreasury_: string;
        }>;
        migrate(migrator_: string, arguments_: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        multicall(data_: BytesLike[], overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        recognizeLoss(overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        recoverPosition(overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        referralCode(overrides?: CallOverrides): Promise<[number]>;
        removeImpairment(assets_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        securityAdmin(overrides?: CallOverrides): Promise<[string] & {
            securityAdmin_: string;
        }>;
        setImplementation(implementation_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setMetadata(metadata_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setReferralCode(referralCode_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setStrategyDelegateFeeRate(strategyDelegateFeeRate_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setStrategyProtocolFeeRate(strategyProtocolFeeRate_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setUseVirtualUnderlyingBalance(useVirtualUnderlyingBalance_: boolean, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        strategyDelegate(overrides?: CallOverrides): Promise<[string] & {
            strategyDelegate_: string;
        }>;
        strategyDelegateFeeRate(overrides?: CallOverrides): Promise<[number]>;
        strategyManager(overrides?: CallOverrides): Promise<[string]>;
        strategyMetadata(overrides?: CallOverrides): Promise<[string]>;
        strategyProtocolFeeRate(overrides?: CallOverrides): Promise<[number]>;
        unrealizedLosses(overrides?: CallOverrides): Promise<[BigNumber] & {
            unrealizedLosses_: BigNumber;
        }>;
        upgrade(version_: BigNumberish, arguments_: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        useVirtualUnderlyingBalance(overrides?: CallOverrides): Promise<[boolean]>;
        withdrawFromUnderlyingStrategy(destination_: string, assets_: BigNumberish, arg2: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
    };
    HUNDRED_PERCENT(overrides?: CallOverrides): Promise<BigNumber>;
    STRATEGY_TYPE(overrides?: CallOverrides): Promise<string>;
    aavePool(overrides?: CallOverrides): Promise<string>;
    aaveToken(overrides?: CallOverrides): Promise<string>;
    assetsUnderManagement(overrides?: CallOverrides): Promise<BigNumber>;
    availableToWithdraw(overrides?: CallOverrides): Promise<BigNumber>;
    claimRewards(assets_: string[], amount_: BigNumberish, rewardToken_: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    factory(overrides?: CallOverrides): Promise<string>;
    fundUnderlyingStrategy(assetsIn_: BigNumberish, arg1: BytesLike, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    fundsAsset(overrides?: CallOverrides): Promise<string>;
    globals(overrides?: CallOverrides): Promise<string>;
    impair(assets_: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    impairedAssets(overrides?: CallOverrides): Promise<BigNumber>;
    implementation(overrides?: CallOverrides): Promise<string>;
    isLossRecognized(overrides?: CallOverrides): Promise<boolean>;
    lastRecordedTotalAssets(overrides?: CallOverrides): Promise<BigNumber>;
    mapleTreasury(overrides?: CallOverrides): Promise<string>;
    migrate(migrator_: string, arguments_: BytesLike, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    multicall(data_: BytesLike[], overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    recognizeLoss(overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    recoverPosition(overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    referralCode(overrides?: CallOverrides): Promise<number>;
    removeImpairment(assets_: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    securityAdmin(overrides?: CallOverrides): Promise<string>;
    setImplementation(implementation_: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setMetadata(metadata_: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setReferralCode(referralCode_: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setStrategyDelegateFeeRate(strategyDelegateFeeRate_: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setStrategyProtocolFeeRate(strategyProtocolFeeRate_: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setUseVirtualUnderlyingBalance(useVirtualUnderlyingBalance_: boolean, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    strategyDelegate(overrides?: CallOverrides): Promise<string>;
    strategyDelegateFeeRate(overrides?: CallOverrides): Promise<number>;
    strategyManager(overrides?: CallOverrides): Promise<string>;
    strategyMetadata(overrides?: CallOverrides): Promise<string>;
    strategyProtocolFeeRate(overrides?: CallOverrides): Promise<number>;
    unrealizedLosses(overrides?: CallOverrides): Promise<BigNumber>;
    upgrade(version_: BigNumberish, arguments_: BytesLike, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    useVirtualUnderlyingBalance(overrides?: CallOverrides): Promise<boolean>;
    withdrawFromUnderlyingStrategy(destination_: string, assets_: BigNumberish, arg2: BytesLike, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    callStatic: {
        HUNDRED_PERCENT(overrides?: CallOverrides): Promise<BigNumber>;
        STRATEGY_TYPE(overrides?: CallOverrides): Promise<string>;
        aavePool(overrides?: CallOverrides): Promise<string>;
        aaveToken(overrides?: CallOverrides): Promise<string>;
        assetsUnderManagement(overrides?: CallOverrides): Promise<BigNumber>;
        availableToWithdraw(overrides?: CallOverrides): Promise<BigNumber>;
        claimRewards(assets_: string[], amount_: BigNumberish, rewardToken_: string, overrides?: CallOverrides): Promise<void>;
        factory(overrides?: CallOverrides): Promise<string>;
        fundUnderlyingStrategy(assetsIn_: BigNumberish, arg1: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
        fundsAsset(overrides?: CallOverrides): Promise<string>;
        globals(overrides?: CallOverrides): Promise<string>;
        impair(assets_: BigNumberish, overrides?: CallOverrides): Promise<void>;
        impairedAssets(overrides?: CallOverrides): Promise<BigNumber>;
        implementation(overrides?: CallOverrides): Promise<string>;
        isLossRecognized(overrides?: CallOverrides): Promise<boolean>;
        lastRecordedTotalAssets(overrides?: CallOverrides): Promise<BigNumber>;
        mapleTreasury(overrides?: CallOverrides): Promise<string>;
        migrate(migrator_: string, arguments_: BytesLike, overrides?: CallOverrides): Promise<void>;
        multicall(data_: BytesLike[], overrides?: CallOverrides): Promise<void>;
        recognizeLoss(overrides?: CallOverrides): Promise<void>;
        recoverPosition(overrides?: CallOverrides): Promise<void>;
        referralCode(overrides?: CallOverrides): Promise<number>;
        removeImpairment(assets_: BigNumberish, overrides?: CallOverrides): Promise<void>;
        securityAdmin(overrides?: CallOverrides): Promise<string>;
        setImplementation(implementation_: string, overrides?: CallOverrides): Promise<void>;
        setMetadata(metadata_: string, overrides?: CallOverrides): Promise<void>;
        setReferralCode(referralCode_: BigNumberish, overrides?: CallOverrides): Promise<void>;
        setStrategyDelegateFeeRate(strategyDelegateFeeRate_: BigNumberish, overrides?: CallOverrides): Promise<void>;
        setStrategyProtocolFeeRate(strategyProtocolFeeRate_: BigNumberish, overrides?: CallOverrides): Promise<void>;
        setUseVirtualUnderlyingBalance(useVirtualUnderlyingBalance_: boolean, overrides?: CallOverrides): Promise<void>;
        strategyDelegate(overrides?: CallOverrides): Promise<string>;
        strategyDelegateFeeRate(overrides?: CallOverrides): Promise<number>;
        strategyManager(overrides?: CallOverrides): Promise<string>;
        strategyMetadata(overrides?: CallOverrides): Promise<string>;
        strategyProtocolFeeRate(overrides?: CallOverrides): Promise<number>;
        unrealizedLosses(overrides?: CallOverrides): Promise<BigNumber>;
        upgrade(version_: BigNumberish, arguments_: BytesLike, overrides?: CallOverrides): Promise<void>;
        useVirtualUnderlyingBalance(overrides?: CallOverrides): Promise<boolean>;
        withdrawFromUnderlyingStrategy(destination_: string, assets_: BigNumberish, arg2: BytesLike, overrides?: CallOverrides): Promise<void>;
    };
    filters: {
        "Initialized(address,(address,uint32,uint32,uint16,bool,string))"(strategyManager?: string | null, params?: null): InitializedEventFilter;
        Initialized(strategyManager?: string | null, params?: null): InitializedEventFilter;
        "Impaired(uint256)"(assets?: null): ImpairedEventFilter;
        Impaired(assets?: null): ImpairedEventFilter;
        "ImpairmentRemoved(uint256)"(assets?: null): ImpairmentRemovedEventFilter;
        ImpairmentRemoved(assets?: null): ImpairmentRemovedEventFilter;
        "LossRecognized()"(): LossRecognizedEventFilter;
        LossRecognized(): LossRecognizedEventFilter;
        "PositionRecovered(uint256)"(shares?: null): PositionRecoveredEventFilter;
        PositionRecovered(shares?: null): PositionRecoveredEventFilter;
        "ReferralCodeSet(uint16)"(referralCode?: null): ReferralCodeSetEventFilter;
        ReferralCodeSet(referralCode?: null): ReferralCodeSetEventFilter;
        "RewardsClaimed(address,uint256)"(rewardToken?: string | null, amount?: null): RewardsClaimedEventFilter;
        RewardsClaimed(rewardToken?: string | null, amount?: null): RewardsClaimedEventFilter;
        "StrategyDelegateFeeRateSet(uint32)"(strategyDelegateFeeRate?: null): StrategyDelegateFeeRateSetEventFilter;
        StrategyDelegateFeeRateSet(strategyDelegateFeeRate?: null): StrategyDelegateFeeRateSetEventFilter;
        "StrategyFeesCollected(uint256,uint256)"(delegateFee?: null, protocolFee?: null): StrategyFeesCollectedEventFilter;
        StrategyFeesCollected(delegateFee?: null, protocolFee?: null): StrategyFeesCollectedEventFilter;
        "StrategyFunded(address,uint256,uint256)"(strategyManager?: string | null, assetsIn?: null, deployedAssets?: null): StrategyFundedEventFilter;
        StrategyFunded(strategyManager?: string | null, assetsIn?: null, deployedAssets?: null): StrategyFundedEventFilter;
        "StrategyMetadataSet(string)"(strategyMetadata?: null): StrategyMetadataSetEventFilter;
        StrategyMetadataSet(strategyMetadata?: null): StrategyMetadataSetEventFilter;
        "StrategyProtocolFeeRateSet(uint32)"(strategyProtocolFeeRate?: null): StrategyProtocolFeeRateSetEventFilter;
        StrategyProtocolFeeRateSet(strategyProtocolFeeRate?: null): StrategyProtocolFeeRateSetEventFilter;
        "StrategyWithdrawal(address,uint256)"(destination?: string | null, assetsOut?: null): StrategyWithdrawalEventFilter;
        StrategyWithdrawal(destination?: string | null, assetsOut?: null): StrategyWithdrawalEventFilter;
        "Upgraded(uint256,bytes)"(toVersion_?: null, arguments_?: null): UpgradedEventFilter;
        Upgraded(toVersion_?: null, arguments_?: null): UpgradedEventFilter;
        "UseVirtualUnderlyingBalanceSet(bool)"(useVirtualUnderlyingBalance?: null): UseVirtualUnderlyingBalanceSetEventFilter;
        UseVirtualUnderlyingBalanceSet(useVirtualUnderlyingBalance?: null): UseVirtualUnderlyingBalanceSetEventFilter;
    };
    estimateGas: {
        HUNDRED_PERCENT(overrides?: CallOverrides): Promise<BigNumber>;
        STRATEGY_TYPE(overrides?: CallOverrides): Promise<BigNumber>;
        aavePool(overrides?: CallOverrides): Promise<BigNumber>;
        aaveToken(overrides?: CallOverrides): Promise<BigNumber>;
        assetsUnderManagement(overrides?: CallOverrides): Promise<BigNumber>;
        availableToWithdraw(overrides?: CallOverrides): Promise<BigNumber>;
        claimRewards(assets_: string[], amount_: BigNumberish, rewardToken_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        factory(overrides?: CallOverrides): Promise<BigNumber>;
        fundUnderlyingStrategy(assetsIn_: BigNumberish, arg1: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        fundsAsset(overrides?: CallOverrides): Promise<BigNumber>;
        globals(overrides?: CallOverrides): Promise<BigNumber>;
        impair(assets_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        impairedAssets(overrides?: CallOverrides): Promise<BigNumber>;
        implementation(overrides?: CallOverrides): Promise<BigNumber>;
        isLossRecognized(overrides?: CallOverrides): Promise<BigNumber>;
        lastRecordedTotalAssets(overrides?: CallOverrides): Promise<BigNumber>;
        mapleTreasury(overrides?: CallOverrides): Promise<BigNumber>;
        migrate(migrator_: string, arguments_: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        multicall(data_: BytesLike[], overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        recognizeLoss(overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        recoverPosition(overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        referralCode(overrides?: CallOverrides): Promise<BigNumber>;
        removeImpairment(assets_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        securityAdmin(overrides?: CallOverrides): Promise<BigNumber>;
        setImplementation(implementation_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setMetadata(metadata_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setReferralCode(referralCode_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setStrategyDelegateFeeRate(strategyDelegateFeeRate_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setStrategyProtocolFeeRate(strategyProtocolFeeRate_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setUseVirtualUnderlyingBalance(useVirtualUnderlyingBalance_: boolean, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        strategyDelegate(overrides?: CallOverrides): Promise<BigNumber>;
        strategyDelegateFeeRate(overrides?: CallOverrides): Promise<BigNumber>;
        strategyManager(overrides?: CallOverrides): Promise<BigNumber>;
        strategyMetadata(overrides?: CallOverrides): Promise<BigNumber>;
        strategyProtocolFeeRate(overrides?: CallOverrides): Promise<BigNumber>;
        unrealizedLosses(overrides?: CallOverrides): Promise<BigNumber>;
        upgrade(version_: BigNumberish, arguments_: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        useVirtualUnderlyingBalance(overrides?: CallOverrides): Promise<BigNumber>;
        withdrawFromUnderlyingStrategy(destination_: string, assets_: BigNumberish, arg2: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
    };
    populateTransaction: {
        HUNDRED_PERCENT(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        STRATEGY_TYPE(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        aavePool(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        aaveToken(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        assetsUnderManagement(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        availableToWithdraw(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        claimRewards(assets_: string[], amount_: BigNumberish, rewardToken_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        factory(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        fundUnderlyingStrategy(assetsIn_: BigNumberish, arg1: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        fundsAsset(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        globals(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        impair(assets_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        impairedAssets(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        implementation(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        isLossRecognized(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        lastRecordedTotalAssets(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        mapleTreasury(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        migrate(migrator_: string, arguments_: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        multicall(data_: BytesLike[], overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        recognizeLoss(overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        recoverPosition(overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        referralCode(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        removeImpairment(assets_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        securityAdmin(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        setImplementation(implementation_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setMetadata(metadata_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setReferralCode(referralCode_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setStrategyDelegateFeeRate(strategyDelegateFeeRate_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setStrategyProtocolFeeRate(strategyProtocolFeeRate_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setUseVirtualUnderlyingBalance(useVirtualUnderlyingBalance_: boolean, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        strategyDelegate(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        strategyDelegateFeeRate(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        strategyManager(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        strategyMetadata(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        strategyProtocolFeeRate(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        unrealizedLosses(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        upgrade(version_: BigNumberish, arguments_: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        useVirtualUnderlyingBalance(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        withdrawFromUnderlyingStrategy(destination_: string, assets_: BigNumberish, arg2: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
    };
}