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 interface PoolManagerV500AbiInterface extends utils.Interface {
    functions: {
        "HUNDRED_PERCENT()": FunctionFragment;
        "acceptPoolDelegate()": FunctionFragment;
        "active()": FunctionFragment;
        "addStrategy(address,bytes32,bytes)": FunctionFragment;
        "addStrategyManager(address)": FunctionFragment;
        "asset()": FunctionFragment;
        "canCall(bytes32,address,bytes)": FunctionFragment;
        "completeConfiguration()": FunctionFragment;
        "configured()": FunctionFragment;
        "convertToExitShares(uint256)": FunctionFragment;
        "delegateManagementFeeRate()": FunctionFragment;
        "factory()": FunctionFragment;
        "getEscrowParams(address,uint256)": FunctionFragment;
        "globals()": FunctionFragment;
        "governor()": FunctionFragment;
        "hasSufficientCover()": FunctionFragment;
        "implementation()": FunctionFragment;
        "isStrategy(address)": FunctionFragment;
        "isStrategyManager(address)": FunctionFragment;
        "liquidityCap()": FunctionFragment;
        "maxDeposit(address)": FunctionFragment;
        "maxMint(address)": FunctionFragment;
        "maxRedeem(address)": FunctionFragment;
        "maxWithdraw(address)": FunctionFragment;
        "migrate(address,bytes)": FunctionFragment;
        "multicall(bytes[])": FunctionFragment;
        "pendingPoolDelegate()": FunctionFragment;
        "pool()": FunctionFragment;
        "poolDelegate()": FunctionFragment;
        "poolPermissionManager()": FunctionFragment;
        "previewRedeem(address,uint256)": FunctionFragment;
        "previewWithdraw(address,uint256)": FunctionFragment;
        "processRedeem(uint256,address,address)": FunctionFragment;
        "processWithdraw(uint256,address,address)": FunctionFragment;
        "removeShares(uint256,address)": FunctionFragment;
        "removeStrategyManager(address)": FunctionFragment;
        "requestFunds(address,uint256)": FunctionFragment;
        "requestRedeem(uint256,address,address)": FunctionFragment;
        "requestWithdraw(uint256,uint256,address,address)": FunctionFragment;
        "setActive(bool)": FunctionFragment;
        "setDelegateManagementFeeRate(uint256)": FunctionFragment;
        "setImplementation(address)": FunctionFragment;
        "setLiquidityCap(uint256)": FunctionFragment;
        "setPendingPoolDelegate(address)": FunctionFragment;
        "setPoolPermissionManager(address)": FunctionFragment;
        "setStrategyCap(address,uint256)": FunctionFragment;
        "setWithdrawalManager(address)": FunctionFragment;
        "strategyCapOf(address)": FunctionFragment;
        "strategyList(uint256)": FunctionFragment;
        "strategyListLength()": FunctionFragment;
        "totalAssets()": FunctionFragment;
        "triggerDefault(address)": FunctionFragment;
        "unrealizedLosses()": FunctionFragment;
        "upgrade(uint256,bytes)": FunctionFragment;
        "withdrawalManager()": FunctionFragment;
    };
    getFunction(nameOrSignatureOrTopic: "HUNDRED_PERCENT" | "acceptPoolDelegate" | "active" | "addStrategy" | "addStrategyManager" | "asset" | "canCall" | "completeConfiguration" | "configured" | "convertToExitShares" | "delegateManagementFeeRate" | "factory" | "getEscrowParams" | "globals" | "governor" | "hasSufficientCover" | "implementation" | "isStrategy" | "isStrategyManager" | "liquidityCap" | "maxDeposit" | "maxMint" | "maxRedeem" | "maxWithdraw" | "migrate" | "multicall" | "pendingPoolDelegate" | "pool" | "poolDelegate" | "poolPermissionManager" | "previewRedeem" | "previewWithdraw" | "processRedeem" | "processWithdraw" | "removeShares" | "removeStrategyManager" | "requestFunds" | "requestRedeem" | "requestWithdraw" | "setActive" | "setDelegateManagementFeeRate" | "setImplementation" | "setLiquidityCap" | "setPendingPoolDelegate" | "setPoolPermissionManager" | "setStrategyCap" | "setWithdrawalManager" | "strategyCapOf" | "strategyList" | "strategyListLength" | "totalAssets" | "triggerDefault" | "unrealizedLosses" | "upgrade" | "withdrawalManager"): FunctionFragment;
    encodeFunctionData(functionFragment: "HUNDRED_PERCENT", values?: undefined): string;
    encodeFunctionData(functionFragment: "acceptPoolDelegate", values?: undefined): string;
    encodeFunctionData(functionFragment: "active", values?: undefined): string;
    encodeFunctionData(functionFragment: "addStrategy", values: [string, BytesLike, BytesLike]): string;
    encodeFunctionData(functionFragment: "addStrategyManager", values: [string]): string;
    encodeFunctionData(functionFragment: "asset", values?: undefined): string;
    encodeFunctionData(functionFragment: "canCall", values: [BytesLike, string, BytesLike]): string;
    encodeFunctionData(functionFragment: "completeConfiguration", values?: undefined): string;
    encodeFunctionData(functionFragment: "configured", values?: undefined): string;
    encodeFunctionData(functionFragment: "convertToExitShares", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "delegateManagementFeeRate", values?: undefined): string;
    encodeFunctionData(functionFragment: "factory", values?: undefined): string;
    encodeFunctionData(functionFragment: "getEscrowParams", values: [string, BigNumberish]): string;
    encodeFunctionData(functionFragment: "globals", values?: undefined): string;
    encodeFunctionData(functionFragment: "governor", values?: undefined): string;
    encodeFunctionData(functionFragment: "hasSufficientCover", values?: undefined): string;
    encodeFunctionData(functionFragment: "implementation", values?: undefined): string;
    encodeFunctionData(functionFragment: "isStrategy", values: [string]): string;
    encodeFunctionData(functionFragment: "isStrategyManager", values: [string]): string;
    encodeFunctionData(functionFragment: "liquidityCap", values?: undefined): string;
    encodeFunctionData(functionFragment: "maxDeposit", values: [string]): string;
    encodeFunctionData(functionFragment: "maxMint", values: [string]): string;
    encodeFunctionData(functionFragment: "maxRedeem", values: [string]): string;
    encodeFunctionData(functionFragment: "maxWithdraw", values: [string]): string;
    encodeFunctionData(functionFragment: "migrate", values: [string, BytesLike]): string;
    encodeFunctionData(functionFragment: "multicall", values: [BytesLike[]]): string;
    encodeFunctionData(functionFragment: "pendingPoolDelegate", values?: undefined): string;
    encodeFunctionData(functionFragment: "pool", values?: undefined): string;
    encodeFunctionData(functionFragment: "poolDelegate", values?: undefined): string;
    encodeFunctionData(functionFragment: "poolPermissionManager", values?: undefined): string;
    encodeFunctionData(functionFragment: "previewRedeem", values: [string, BigNumberish]): string;
    encodeFunctionData(functionFragment: "previewWithdraw", values: [string, BigNumberish]): string;
    encodeFunctionData(functionFragment: "processRedeem", values: [BigNumberish, string, string]): string;
    encodeFunctionData(functionFragment: "processWithdraw", values: [BigNumberish, string, string]): string;
    encodeFunctionData(functionFragment: "removeShares", values: [BigNumberish, string]): string;
    encodeFunctionData(functionFragment: "removeStrategyManager", values: [string]): string;
    encodeFunctionData(functionFragment: "requestFunds", values: [string, BigNumberish]): string;
    encodeFunctionData(functionFragment: "requestRedeem", values: [BigNumberish, string, string]): string;
    encodeFunctionData(functionFragment: "requestWithdraw", values: [BigNumberish, BigNumberish, string, string]): string;
    encodeFunctionData(functionFragment: "setActive", values: [boolean]): string;
    encodeFunctionData(functionFragment: "setDelegateManagementFeeRate", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "setImplementation", values: [string]): string;
    encodeFunctionData(functionFragment: "setLiquidityCap", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "setPendingPoolDelegate", values: [string]): string;
    encodeFunctionData(functionFragment: "setPoolPermissionManager", values: [string]): string;
    encodeFunctionData(functionFragment: "setStrategyCap", values: [string, BigNumberish]): string;
    encodeFunctionData(functionFragment: "setWithdrawalManager", values: [string]): string;
    encodeFunctionData(functionFragment: "strategyCapOf", values: [string]): string;
    encodeFunctionData(functionFragment: "strategyList", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "strategyListLength", values?: undefined): string;
    encodeFunctionData(functionFragment: "totalAssets", values?: undefined): string;
    encodeFunctionData(functionFragment: "triggerDefault", values: [string]): string;
    encodeFunctionData(functionFragment: "unrealizedLosses", values?: undefined): string;
    encodeFunctionData(functionFragment: "upgrade", values: [BigNumberish, BytesLike]): string;
    encodeFunctionData(functionFragment: "withdrawalManager", values?: undefined): string;
    decodeFunctionResult(functionFragment: "HUNDRED_PERCENT", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "acceptPoolDelegate", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "active", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "addStrategy", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "addStrategyManager", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "asset", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "canCall", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "completeConfiguration", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "configured", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "convertToExitShares", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "delegateManagementFeeRate", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "factory", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getEscrowParams", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "globals", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "governor", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "hasSufficientCover", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "implementation", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "isStrategy", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "isStrategyManager", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "liquidityCap", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "maxDeposit", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "maxMint", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "maxRedeem", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "maxWithdraw", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "migrate", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "multicall", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "pendingPoolDelegate", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "pool", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "poolDelegate", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "poolPermissionManager", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "previewRedeem", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "previewWithdraw", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "processRedeem", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "processWithdraw", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "removeShares", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "removeStrategyManager", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "requestFunds", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "requestRedeem", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "requestWithdraw", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setActive", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setDelegateManagementFeeRate", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setImplementation", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setLiquidityCap", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setPendingPoolDelegate", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setPoolPermissionManager", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setStrategyCap", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setWithdrawalManager", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "strategyCapOf", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "strategyList", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "strategyListLength", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "totalAssets", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "triggerDefault", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "unrealizedLosses", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "upgrade", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "withdrawalManager", data: BytesLike): Result;
    events: {
        "Initialized(address,address,address)": EventFragment;
        "CollateralLiquidationFinished(address,uint256)": EventFragment;
        "DelegateManagementFeeRateSet(uint256)": EventFragment;
        "LiquidityCapSet(uint256)": EventFragment;
        "PendingDelegateAccepted(address,address)": EventFragment;
        "PendingDelegateSet(address,address)": EventFragment;
        "PoolConfigurationComplete()": EventFragment;
        "PoolPermissionManagerSet(address)": EventFragment;
        "RedeemProcessed(address,uint256,uint256)": EventFragment;
        "RedeemRequested(address,uint256)": EventFragment;
        "SetAsActive(bool)": EventFragment;
        "SharesRemoved(address,uint256)": EventFragment;
        "StrategyAdded(address)": EventFragment;
        "StrategyCapSet(address,uint256)": EventFragment;
        "StrategyManagerAdded(address)": EventFragment;
        "StrategyManagerRemoved(address)": EventFragment;
        "Upgraded(uint256,bytes)": EventFragment;
        "WithdrawalManagerSet(address)": EventFragment;
    };
    getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "CollateralLiquidationFinished"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "DelegateManagementFeeRateSet"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "LiquidityCapSet"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "PendingDelegateAccepted"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "PendingDelegateSet"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "PoolConfigurationComplete"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "PoolPermissionManagerSet"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "RedeemProcessed"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "RedeemRequested"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "SetAsActive"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "SharesRemoved"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "StrategyAdded"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "StrategyCapSet"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "StrategyManagerAdded"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "StrategyManagerRemoved"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Upgraded"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "WithdrawalManagerSet"): EventFragment;
}
export interface InitializedEventObject {
    owner_: string;
    asset_: string;
    pool_: string;
}
export type InitializedEvent = TypedEvent<[
    string,
    string,
    string
], InitializedEventObject>;
export type InitializedEventFilter = TypedEventFilter<InitializedEvent>;
export interface CollateralLiquidationFinishedEventObject {
    loan_: string;
    unrealizedLosses_: BigNumber;
}
export type CollateralLiquidationFinishedEvent = TypedEvent<[
    string,
    BigNumber
], CollateralLiquidationFinishedEventObject>;
export type CollateralLiquidationFinishedEventFilter = TypedEventFilter<CollateralLiquidationFinishedEvent>;
export interface DelegateManagementFeeRateSetEventObject {
    managementFeeRate: BigNumber;
}
export type DelegateManagementFeeRateSetEvent = TypedEvent<[
    BigNumber
], DelegateManagementFeeRateSetEventObject>;
export type DelegateManagementFeeRateSetEventFilter = TypedEventFilter<DelegateManagementFeeRateSetEvent>;
export interface LiquidityCapSetEventObject {
    liquidityCap: BigNumber;
}
export type LiquidityCapSetEvent = TypedEvent<[
    BigNumber
], LiquidityCapSetEventObject>;
export type LiquidityCapSetEventFilter = TypedEventFilter<LiquidityCapSetEvent>;
export interface PendingDelegateAcceptedEventObject {
    previousDelegate: string;
    newDelegate: string;
}
export type PendingDelegateAcceptedEvent = TypedEvent<[
    string,
    string
], PendingDelegateAcceptedEventObject>;
export type PendingDelegateAcceptedEventFilter = TypedEventFilter<PendingDelegateAcceptedEvent>;
export interface PendingDelegateSetEventObject {
    previousDelegate: string;
    newDelegate: string;
}
export type PendingDelegateSetEvent = TypedEvent<[
    string,
    string
], PendingDelegateSetEventObject>;
export type PendingDelegateSetEventFilter = TypedEventFilter<PendingDelegateSetEvent>;
export interface PoolConfigurationCompleteEventObject {
}
export type PoolConfigurationCompleteEvent = TypedEvent<[
], PoolConfigurationCompleteEventObject>;
export type PoolConfigurationCompleteEventFilter = TypedEventFilter<PoolConfigurationCompleteEvent>;
export interface PoolPermissionManagerSetEventObject {
    poolPermissionManager: string;
}
export type PoolPermissionManagerSetEvent = TypedEvent<[
    string
], PoolPermissionManagerSetEventObject>;
export type PoolPermissionManagerSetEventFilter = TypedEventFilter<PoolPermissionManagerSetEvent>;
export interface RedeemProcessedEventObject {
    owner: string;
    redeemableShares: BigNumber;
    resultingAssets: BigNumber;
}
export type RedeemProcessedEvent = TypedEvent<[
    string,
    BigNumber,
    BigNumber
], RedeemProcessedEventObject>;
export type RedeemProcessedEventFilter = TypedEventFilter<RedeemProcessedEvent>;
export interface RedeemRequestedEventObject {
    owner: string;
    shares: BigNumber;
}
export type RedeemRequestedEvent = TypedEvent<[
    string,
    BigNumber
], RedeemRequestedEventObject>;
export type RedeemRequestedEventFilter = TypedEventFilter<RedeemRequestedEvent>;
export interface SetAsActiveEventObject {
    active: boolean;
}
export type SetAsActiveEvent = TypedEvent<[boolean], SetAsActiveEventObject>;
export type SetAsActiveEventFilter = TypedEventFilter<SetAsActiveEvent>;
export interface SharesRemovedEventObject {
    owner: string;
    shares: BigNumber;
}
export type SharesRemovedEvent = TypedEvent<[
    string,
    BigNumber
], SharesRemovedEventObject>;
export type SharesRemovedEventFilter = TypedEventFilter<SharesRemovedEvent>;
export interface StrategyAddedEventObject {
    strategy: string;
}
export type StrategyAddedEvent = TypedEvent<[string], StrategyAddedEventObject>;
export type StrategyAddedEventFilter = TypedEventFilter<StrategyAddedEvent>;
export interface StrategyCapSetEventObject {
    strategy: string;
    cap: BigNumber;
}
export type StrategyCapSetEvent = TypedEvent<[
    string,
    BigNumber
], StrategyCapSetEventObject>;
export type StrategyCapSetEventFilter = TypedEventFilter<StrategyCapSetEvent>;
export interface StrategyManagerAddedEventObject {
    strategyManager: string;
}
export type StrategyManagerAddedEvent = TypedEvent<[
    string
], StrategyManagerAddedEventObject>;
export type StrategyManagerAddedEventFilter = TypedEventFilter<StrategyManagerAddedEvent>;
export interface StrategyManagerRemovedEventObject {
    strategyManager: string;
}
export type StrategyManagerRemovedEvent = TypedEvent<[
    string
], StrategyManagerRemovedEventObject>;
export type StrategyManagerRemovedEventFilter = TypedEventFilter<StrategyManagerRemovedEvent>;
export interface UpgradedEventObject {
    toVersion_: BigNumber;
    arguments_: string;
}
export type UpgradedEvent = TypedEvent<[
    BigNumber,
    string
], UpgradedEventObject>;
export type UpgradedEventFilter = TypedEventFilter<UpgradedEvent>;
export interface WithdrawalManagerSetEventObject {
    withdrawalManager: string;
}
export type WithdrawalManagerSetEvent = TypedEvent<[
    string
], WithdrawalManagerSetEventObject>;
export type WithdrawalManagerSetEventFilter = TypedEventFilter<WithdrawalManagerSetEvent>;
export interface PoolManagerV500Abi extends BaseContract {
    connect(signerOrProvider: Signer | Provider | string): this;
    attach(addressOrName: string): this;
    deployed(): Promise<this>;
    interface: PoolManagerV500AbiInterface;
    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]>;
        acceptPoolDelegate(overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        active(overrides?: CallOverrides): Promise<[boolean]>;
        addStrategy(strategyFactory_: string, salt_: BytesLike, extraDeploymentData_: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        addStrategyManager(strategyManager_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        asset(overrides?: CallOverrides): Promise<[string]>;
        canCall(functionId_: BytesLike, caller_: string, data_: BytesLike, overrides?: CallOverrides): Promise<[
            boolean,
            string
        ] & {
            canCall_: boolean;
            errorMessage_: string;
        }>;
        completeConfiguration(overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        configured(overrides?: CallOverrides): Promise<[boolean]>;
        convertToExitShares(assets_: BigNumberish, overrides?: CallOverrides): Promise<[BigNumber] & {
            shares_: BigNumber;
        }>;
        delegateManagementFeeRate(overrides?: CallOverrides): Promise<[BigNumber]>;
        factory(overrides?: CallOverrides): Promise<[string] & {
            factory_: string;
        }>;
        getEscrowParams(arg0: string, shares_: BigNumberish, overrides?: CallOverrides): Promise<[
            BigNumber,
            string
        ] & {
            escrowShares_: BigNumber;
            destination_: string;
        }>;
        globals(overrides?: CallOverrides): Promise<[string] & {
            globals_: string;
        }>;
        governor(overrides?: CallOverrides): Promise<[string] & {
            governor_: string;
        }>;
        hasSufficientCover(overrides?: CallOverrides): Promise<[boolean] & {
            hasSufficientCover_: boolean;
        }>;
        implementation(overrides?: CallOverrides): Promise<[string] & {
            implementation_: string;
        }>;
        isStrategy(arg0: string, overrides?: CallOverrides): Promise<[boolean]>;
        isStrategyManager(arg0: string, overrides?: CallOverrides): Promise<[boolean]>;
        liquidityCap(overrides?: CallOverrides): Promise<[BigNumber]>;
        maxDeposit(receiver_: string, overrides?: CallOverrides): Promise<[BigNumber] & {
            maxAssets_: BigNumber;
        }>;
        maxMint(receiver_: string, overrides?: CallOverrides): Promise<[BigNumber] & {
            maxShares_: BigNumber;
        }>;
        maxRedeem(owner_: string, overrides?: CallOverrides): Promise<[BigNumber] & {
            maxShares_: BigNumber;
        }>;
        maxWithdraw(owner_: string, overrides?: CallOverrides): Promise<[BigNumber] & {
            maxAssets_: BigNumber;
        }>;
        migrate(migrator_: string, arguments_: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        multicall(data_: BytesLike[], overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        pendingPoolDelegate(overrides?: CallOverrides): Promise<[string]>;
        pool(overrides?: CallOverrides): Promise<[string]>;
        poolDelegate(overrides?: CallOverrides): Promise<[string]>;
        poolPermissionManager(overrides?: CallOverrides): Promise<[string]>;
        previewRedeem(owner_: string, shares_: BigNumberish, overrides?: CallOverrides): Promise<[BigNumber] & {
            assets_: BigNumber;
        }>;
        previewWithdraw(owner_: string, assets_: BigNumberish, overrides?: CallOverrides): Promise<[BigNumber] & {
            shares_: BigNumber;
        }>;
        processRedeem(shares_: BigNumberish, owner_: string, sender_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        processWithdraw(assets_: BigNumberish, owner_: string, sender_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        removeShares(shares_: BigNumberish, owner_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        removeStrategyManager(strategyManager_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        requestFunds(destination_: string, amount_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        requestRedeem(shares_: BigNumberish, owner_: string, sender_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        requestWithdraw(shares_: BigNumberish, assets_: BigNumberish, owner_: string, sender_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setActive(active_: boolean, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setDelegateManagementFeeRate(delegateManagementFeeRate_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setImplementation(implementation_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setLiquidityCap(liquidityCap_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setPendingPoolDelegate(pendingPoolDelegate_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setPoolPermissionManager(poolPermissionManager_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setStrategyCap(strategy_: string, cap_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setWithdrawalManager(withdrawalManager_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        strategyCapOf(arg0: string, overrides?: CallOverrides): Promise<[BigNumber]>;
        strategyList(arg0: BigNumberish, overrides?: CallOverrides): Promise<[string]>;
        strategyListLength(overrides?: CallOverrides): Promise<[BigNumber] & {
            strategyListLength_: BigNumber;
        }>;
        totalAssets(overrides?: CallOverrides): Promise<[BigNumber] & {
            totalAssets_: BigNumber;
        }>;
        triggerDefault(loan_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        unrealizedLosses(overrides?: CallOverrides): Promise<[BigNumber] & {
            unrealizedLosses_: BigNumber;
        }>;
        upgrade(version_: BigNumberish, arguments_: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        withdrawalManager(overrides?: CallOverrides): Promise<[string]>;
    };
    HUNDRED_PERCENT(overrides?: CallOverrides): Promise<BigNumber>;
    acceptPoolDelegate(overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    active(overrides?: CallOverrides): Promise<boolean>;
    addStrategy(strategyFactory_: string, salt_: BytesLike, extraDeploymentData_: BytesLike, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    addStrategyManager(strategyManager_: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    asset(overrides?: CallOverrides): Promise<string>;
    canCall(functionId_: BytesLike, caller_: string, data_: BytesLike, overrides?: CallOverrides): Promise<[boolean, string] & {
        canCall_: boolean;
        errorMessage_: string;
    }>;
    completeConfiguration(overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    configured(overrides?: CallOverrides): Promise<boolean>;
    convertToExitShares(assets_: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
    delegateManagementFeeRate(overrides?: CallOverrides): Promise<BigNumber>;
    factory(overrides?: CallOverrides): Promise<string>;
    getEscrowParams(arg0: string, shares_: BigNumberish, overrides?: CallOverrides): Promise<[
        BigNumber,
        string
    ] & {
        escrowShares_: BigNumber;
        destination_: string;
    }>;
    globals(overrides?: CallOverrides): Promise<string>;
    governor(overrides?: CallOverrides): Promise<string>;
    hasSufficientCover(overrides?: CallOverrides): Promise<boolean>;
    implementation(overrides?: CallOverrides): Promise<string>;
    isStrategy(arg0: string, overrides?: CallOverrides): Promise<boolean>;
    isStrategyManager(arg0: string, overrides?: CallOverrides): Promise<boolean>;
    liquidityCap(overrides?: CallOverrides): Promise<BigNumber>;
    maxDeposit(receiver_: string, overrides?: CallOverrides): Promise<BigNumber>;
    maxMint(receiver_: string, overrides?: CallOverrides): Promise<BigNumber>;
    maxRedeem(owner_: string, overrides?: CallOverrides): Promise<BigNumber>;
    maxWithdraw(owner_: string, overrides?: CallOverrides): Promise<BigNumber>;
    migrate(migrator_: string, arguments_: BytesLike, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    multicall(data_: BytesLike[], overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    pendingPoolDelegate(overrides?: CallOverrides): Promise<string>;
    pool(overrides?: CallOverrides): Promise<string>;
    poolDelegate(overrides?: CallOverrides): Promise<string>;
    poolPermissionManager(overrides?: CallOverrides): Promise<string>;
    previewRedeem(owner_: string, shares_: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
    previewWithdraw(owner_: string, assets_: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
    processRedeem(shares_: BigNumberish, owner_: string, sender_: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    processWithdraw(assets_: BigNumberish, owner_: string, sender_: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    removeShares(shares_: BigNumberish, owner_: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    removeStrategyManager(strategyManager_: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    requestFunds(destination_: string, amount_: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    requestRedeem(shares_: BigNumberish, owner_: string, sender_: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    requestWithdraw(shares_: BigNumberish, assets_: BigNumberish, owner_: string, sender_: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setActive(active_: boolean, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setDelegateManagementFeeRate(delegateManagementFeeRate_: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setImplementation(implementation_: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setLiquidityCap(liquidityCap_: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setPendingPoolDelegate(pendingPoolDelegate_: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setPoolPermissionManager(poolPermissionManager_: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setStrategyCap(strategy_: string, cap_: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setWithdrawalManager(withdrawalManager_: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    strategyCapOf(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;
    strategyList(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;
    strategyListLength(overrides?: CallOverrides): Promise<BigNumber>;
    totalAssets(overrides?: CallOverrides): Promise<BigNumber>;
    triggerDefault(loan_: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    unrealizedLosses(overrides?: CallOverrides): Promise<BigNumber>;
    upgrade(version_: BigNumberish, arguments_: BytesLike, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    withdrawalManager(overrides?: CallOverrides): Promise<string>;
    callStatic: {
        HUNDRED_PERCENT(overrides?: CallOverrides): Promise<BigNumber>;
        acceptPoolDelegate(overrides?: CallOverrides): Promise<void>;
        active(overrides?: CallOverrides): Promise<boolean>;
        addStrategy(strategyFactory_: string, salt_: BytesLike, extraDeploymentData_: BytesLike, overrides?: CallOverrides): Promise<string>;
        addStrategyManager(strategyManager_: string, overrides?: CallOverrides): Promise<void>;
        asset(overrides?: CallOverrides): Promise<string>;
        canCall(functionId_: BytesLike, caller_: string, data_: BytesLike, overrides?: CallOverrides): Promise<[
            boolean,
            string
        ] & {
            canCall_: boolean;
            errorMessage_: string;
        }>;
        completeConfiguration(overrides?: CallOverrides): Promise<void>;
        configured(overrides?: CallOverrides): Promise<boolean>;
        convertToExitShares(assets_: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        delegateManagementFeeRate(overrides?: CallOverrides): Promise<BigNumber>;
        factory(overrides?: CallOverrides): Promise<string>;
        getEscrowParams(arg0: string, shares_: BigNumberish, overrides?: CallOverrides): Promise<[
            BigNumber,
            string
        ] & {
            escrowShares_: BigNumber;
            destination_: string;
        }>;
        globals(overrides?: CallOverrides): Promise<string>;
        governor(overrides?: CallOverrides): Promise<string>;
        hasSufficientCover(overrides?: CallOverrides): Promise<boolean>;
        implementation(overrides?: CallOverrides): Promise<string>;
        isStrategy(arg0: string, overrides?: CallOverrides): Promise<boolean>;
        isStrategyManager(arg0: string, overrides?: CallOverrides): Promise<boolean>;
        liquidityCap(overrides?: CallOverrides): Promise<BigNumber>;
        maxDeposit(receiver_: string, overrides?: CallOverrides): Promise<BigNumber>;
        maxMint(receiver_: string, overrides?: CallOverrides): Promise<BigNumber>;
        maxRedeem(owner_: string, overrides?: CallOverrides): Promise<BigNumber>;
        maxWithdraw(owner_: string, overrides?: CallOverrides): Promise<BigNumber>;
        migrate(migrator_: string, arguments_: BytesLike, overrides?: CallOverrides): Promise<void>;
        multicall(data_: BytesLike[], overrides?: CallOverrides): Promise<void>;
        pendingPoolDelegate(overrides?: CallOverrides): Promise<string>;
        pool(overrides?: CallOverrides): Promise<string>;
        poolDelegate(overrides?: CallOverrides): Promise<string>;
        poolPermissionManager(overrides?: CallOverrides): Promise<string>;
        previewRedeem(owner_: string, shares_: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        previewWithdraw(owner_: string, assets_: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        processRedeem(shares_: BigNumberish, owner_: string, sender_: string, overrides?: CallOverrides): Promise<[
            BigNumber,
            BigNumber
        ] & {
            redeemableShares_: BigNumber;
            resultingAssets_: BigNumber;
        }>;
        processWithdraw(assets_: BigNumberish, owner_: string, sender_: string, overrides?: CallOverrides): Promise<[
            BigNumber,
            BigNumber
        ] & {
            redeemableShares_: BigNumber;
            resultingAssets_: BigNumber;
        }>;
        removeShares(shares_: BigNumberish, owner_: string, overrides?: CallOverrides): Promise<BigNumber>;
        removeStrategyManager(strategyManager_: string, overrides?: CallOverrides): Promise<void>;
        requestFunds(destination_: string, amount_: BigNumberish, overrides?: CallOverrides): Promise<void>;
        requestRedeem(shares_: BigNumberish, owner_: string, sender_: string, overrides?: CallOverrides): Promise<void>;
        requestWithdraw(shares_: BigNumberish, assets_: BigNumberish, owner_: string, sender_: string, overrides?: CallOverrides): Promise<void>;
        setActive(active_: boolean, overrides?: CallOverrides): Promise<void>;
        setDelegateManagementFeeRate(delegateManagementFeeRate_: BigNumberish, overrides?: CallOverrides): Promise<void>;
        setImplementation(implementation_: string, overrides?: CallOverrides): Promise<void>;
        setLiquidityCap(liquidityCap_: BigNumberish, overrides?: CallOverrides): Promise<void>;
        setPendingPoolDelegate(pendingPoolDelegate_: string, overrides?: CallOverrides): Promise<void>;
        setPoolPermissionManager(poolPermissionManager_: string, overrides?: CallOverrides): Promise<void>;
        setStrategyCap(strategy_: string, cap_: BigNumberish, overrides?: CallOverrides): Promise<void>;
        setWithdrawalManager(withdrawalManager_: string, overrides?: CallOverrides): Promise<void>;
        strategyCapOf(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;
        strategyList(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;
        strategyListLength(overrides?: CallOverrides): Promise<BigNumber>;
        totalAssets(overrides?: CallOverrides): Promise<BigNumber>;
        triggerDefault(loan_: string, overrides?: CallOverrides): Promise<void>;
        unrealizedLosses(overrides?: CallOverrides): Promise<BigNumber>;
        upgrade(version_: BigNumberish, arguments_: BytesLike, overrides?: CallOverrides): Promise<void>;
        withdrawalManager(overrides?: CallOverrides): Promise<string>;
    };
    filters: {
        "Initialized(address,address,address)"(owner_?: null, asset_?: null, pool_?: null): InitializedEventFilter;
        Initialized(owner_?: null, asset_?: null, pool_?: null): InitializedEventFilter;
        "CollateralLiquidationFinished(address,uint256)"(loan_?: string | null, unrealizedLosses_?: null): CollateralLiquidationFinishedEventFilter;
        CollateralLiquidationFinished(loan_?: string | null, unrealizedLosses_?: null): CollateralLiquidationFinishedEventFilter;
        "DelegateManagementFeeRateSet(uint256)"(managementFeeRate?: null): DelegateManagementFeeRateSetEventFilter;
        DelegateManagementFeeRateSet(managementFeeRate?: null): DelegateManagementFeeRateSetEventFilter;
        "LiquidityCapSet(uint256)"(liquidityCap?: null): LiquidityCapSetEventFilter;
        LiquidityCapSet(liquidityCap?: null): LiquidityCapSetEventFilter;
        "PendingDelegateAccepted(address,address)"(previousDelegate?: string | null, newDelegate?: string | null): PendingDelegateAcceptedEventFilter;
        PendingDelegateAccepted(previousDelegate?: string | null, newDelegate?: string | null): PendingDelegateAcceptedEventFilter;
        "PendingDelegateSet(address,address)"(previousDelegate?: string | null, newDelegate?: string | null): PendingDelegateSetEventFilter;
        PendingDelegateSet(previousDelegate?: string | null, newDelegate?: string | null): PendingDelegateSetEventFilter;
        "PoolConfigurationComplete()"(): PoolConfigurationCompleteEventFilter;
        PoolConfigurationComplete(): PoolConfigurationCompleteEventFilter;
        "PoolPermissionManagerSet(address)"(poolPermissionManager?: string | null): PoolPermissionManagerSetEventFilter;
        PoolPermissionManagerSet(poolPermissionManager?: string | null): PoolPermissionManagerSetEventFilter;
        "RedeemProcessed(address,uint256,uint256)"(owner?: string | null, redeemableShares?: null, resultingAssets?: null): RedeemProcessedEventFilter;
        RedeemProcessed(owner?: string | null, redeemableShares?: null, resultingAssets?: null): RedeemProcessedEventFilter;
        "RedeemRequested(address,uint256)"(owner?: string | null, shares?: null): RedeemRequestedEventFilter;
        RedeemRequested(owner?: string | null, shares?: null): RedeemRequestedEventFilter;
        "SetAsActive(bool)"(active?: null): SetAsActiveEventFilter;
        SetAsActive(active?: null): SetAsActiveEventFilter;
        "SharesRemoved(address,uint256)"(owner?: string | null, shares?: null): SharesRemovedEventFilter;
        SharesRemoved(owner?: string | null, shares?: null): SharesRemovedEventFilter;
        "StrategyAdded(address)"(strategy?: string | null): StrategyAddedEventFilter;
        StrategyAdded(strategy?: string | null): StrategyAddedEventFilter;
        "StrategyCapSet(address,uint256)"(strategy?: string | null, cap?: null): StrategyCapSetEventFilter;
        StrategyCapSet(strategy?: string | null, cap?: null): StrategyCapSetEventFilter;
        "StrategyManagerAdded(address)"(strategyManager?: string | null): StrategyManagerAddedEventFilter;
        StrategyManagerAdded(strategyManager?: string | null): StrategyManagerAddedEventFilter;
        "StrategyManagerRemoved(address)"(strategyManager?: string | null): StrategyManagerRemovedEventFilter;
        StrategyManagerRemoved(strategyManager?: string | null): StrategyManagerRemovedEventFilter;
        "Upgraded(uint256,bytes)"(toVersion_?: null, arguments_?: null): UpgradedEventFilter;
        Upgraded(toVersion_?: null, arguments_?: null): UpgradedEventFilter;
        "WithdrawalManagerSet(address)"(withdrawalManager?: string | null): WithdrawalManagerSetEventFilter;
        WithdrawalManagerSet(withdrawalManager?: string | null): WithdrawalManagerSetEventFilter;
    };
    estimateGas: {
        HUNDRED_PERCENT(overrides?: CallOverrides): Promise<BigNumber>;
        acceptPoolDelegate(overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        active(overrides?: CallOverrides): Promise<BigNumber>;
        addStrategy(strategyFactory_: string, salt_: BytesLike, extraDeploymentData_: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        addStrategyManager(strategyManager_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        asset(overrides?: CallOverrides): Promise<BigNumber>;
        canCall(functionId_: BytesLike, caller_: string, data_: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
        completeConfiguration(overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        configured(overrides?: CallOverrides): Promise<BigNumber>;
        convertToExitShares(assets_: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        delegateManagementFeeRate(overrides?: CallOverrides): Promise<BigNumber>;
        factory(overrides?: CallOverrides): Promise<BigNumber>;
        getEscrowParams(arg0: string, shares_: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        globals(overrides?: CallOverrides): Promise<BigNumber>;
        governor(overrides?: CallOverrides): Promise<BigNumber>;
        hasSufficientCover(overrides?: CallOverrides): Promise<BigNumber>;
        implementation(overrides?: CallOverrides): Promise<BigNumber>;
        isStrategy(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;
        isStrategyManager(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;
        liquidityCap(overrides?: CallOverrides): Promise<BigNumber>;
        maxDeposit(receiver_: string, overrides?: CallOverrides): Promise<BigNumber>;
        maxMint(receiver_: string, overrides?: CallOverrides): Promise<BigNumber>;
        maxRedeem(owner_: string, overrides?: CallOverrides): Promise<BigNumber>;
        maxWithdraw(owner_: string, overrides?: CallOverrides): Promise<BigNumber>;
        migrate(migrator_: string, arguments_: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        multicall(data_: BytesLike[], overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        pendingPoolDelegate(overrides?: CallOverrides): Promise<BigNumber>;
        pool(overrides?: CallOverrides): Promise<BigNumber>;
        poolDelegate(overrides?: CallOverrides): Promise<BigNumber>;
        poolPermissionManager(overrides?: CallOverrides): Promise<BigNumber>;
        previewRedeem(owner_: string, shares_: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        previewWithdraw(owner_: string, assets_: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        processRedeem(shares_: BigNumberish, owner_: string, sender_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        processWithdraw(assets_: BigNumberish, owner_: string, sender_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        removeShares(shares_: BigNumberish, owner_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        removeStrategyManager(strategyManager_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        requestFunds(destination_: string, amount_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        requestRedeem(shares_: BigNumberish, owner_: string, sender_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        requestWithdraw(shares_: BigNumberish, assets_: BigNumberish, owner_: string, sender_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setActive(active_: boolean, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setDelegateManagementFeeRate(delegateManagementFeeRate_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setImplementation(implementation_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setLiquidityCap(liquidityCap_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setPendingPoolDelegate(pendingPoolDelegate_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setPoolPermissionManager(poolPermissionManager_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setStrategyCap(strategy_: string, cap_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setWithdrawalManager(withdrawalManager_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        strategyCapOf(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;
        strategyList(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        strategyListLength(overrides?: CallOverrides): Promise<BigNumber>;
        totalAssets(overrides?: CallOverrides): Promise<BigNumber>;
        triggerDefault(loan_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        unrealizedLosses(overrides?: CallOverrides): Promise<BigNumber>;
        upgrade(version_: BigNumberish, arguments_: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        withdrawalManager(overrides?: CallOverrides): Promise<BigNumber>;
    };
    populateTransaction: {
        HUNDRED_PERCENT(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        acceptPoolDelegate(overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        active(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        addStrategy(strategyFactory_: string, salt_: BytesLike, extraDeploymentData_: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        addStrategyManager(strategyManager_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        asset(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        canCall(functionId_: BytesLike, caller_: string, data_: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        completeConfiguration(overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        configured(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        convertToExitShares(assets_: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        delegateManagementFeeRate(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        factory(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getEscrowParams(arg0: string, shares_: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        globals(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        governor(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        hasSufficientCover(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        implementation(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        isStrategy(arg0: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        isStrategyManager(arg0: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        liquidityCap(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        maxDeposit(receiver_: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        maxMint(receiver_: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        maxRedeem(owner_: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        maxWithdraw(owner_: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        migrate(migrator_: string, arguments_: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        multicall(data_: BytesLike[], overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        pendingPoolDelegate(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        pool(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        poolDelegate(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        poolPermissionManager(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        previewRedeem(owner_: string, shares_: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        previewWithdraw(owner_: string, assets_: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        processRedeem(shares_: BigNumberish, owner_: string, sender_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        processWithdraw(assets_: BigNumberish, owner_: string, sender_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        removeShares(shares_: BigNumberish, owner_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        removeStrategyManager(strategyManager_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        requestFunds(destination_: string, amount_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        requestRedeem(shares_: BigNumberish, owner_: string, sender_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        requestWithdraw(shares_: BigNumberish, assets_: BigNumberish, owner_: string, sender_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setActive(active_: boolean, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setDelegateManagementFeeRate(delegateManagementFeeRate_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setImplementation(implementation_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setLiquidityCap(liquidityCap_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setPendingPoolDelegate(pendingPoolDelegate_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setPoolPermissionManager(poolPermissionManager_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setStrategyCap(strategy_: string, cap_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setWithdrawalManager(withdrawalManager_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        strategyCapOf(arg0: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        strategyList(arg0: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        strategyListLength(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        totalAssets(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        triggerDefault(loan_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        unrealizedLosses(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        upgrade(version_: BigNumberish, arguments_: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        withdrawalManager(overrides?: CallOverrides): Promise<PopulatedTransaction>;
    };
}