/* Autogenerated file. Do not edit manually. */
/* tslint:disable */
/* eslint-disable */
import type {
  BaseContract,
  BigNumber,
  BigNumberish,
  BytesLike,
  CallOverrides,
  ContractTransaction,
  Overrides,
  PopulatedTransaction,
  Signer,
  utils,
} from "ethers";
import type {
  FunctionFragment,
  Result,
  EventFragment,
} from "@ethersproject/abi";
import type { Listener, Provider } from "@ethersproject/providers";
import type {
  TypedEventFilter,
  TypedEvent,
  TypedListener,
  OnEvent,
  PromiseOrValue,
} from "../common";

export declare namespace Types {
  export type MaxGasForMatchingStruct = {
    supply: PromiseOrValue<BigNumberish>;
    borrow: PromiseOrValue<BigNumberish>;
    withdraw: PromiseOrValue<BigNumberish>;
    repay: PromiseOrValue<BigNumberish>;
  };

  export type MaxGasForMatchingStructOutput = [
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber
  ] & {
    supply: BigNumber;
    borrow: BigNumber;
    withdraw: BigNumber;
    repay: BigNumber;
  };

  export type MarketParametersStruct = {
    reserveFactor: PromiseOrValue<BigNumberish>;
    p2pIndexCursor: PromiseOrValue<BigNumberish>;
  };

  export type MarketParametersStructOutput = [number, number] & {
    reserveFactor: number;
    p2pIndexCursor: number;
  };
}

export interface MorphoCompoundInterface extends utils.Interface {
  functions: {
    "CTOKEN_DECIMALS()": FunctionFragment;
    "MAX_BASIS_POINTS()": FunctionFragment;
    "MAX_CLAIMABLE_RESERVE()": FunctionFragment;
    "WAD()": FunctionFragment;
    "borrow(address,uint256)": FunctionFragment;
    "borrow(address,uint256,uint256)": FunctionFragment;
    "borrowBalanceInOf(address,address)": FunctionFragment;
    "cEth()": FunctionFragment;
    "claimRewards(address[],bool)": FunctionFragment;
    "claimToTreasury(address,uint256)": FunctionFragment;
    "comptroller()": FunctionFragment;
    "createMarket(address,(uint16,uint16))": FunctionFragment;
    "defaultMaxGasForMatching()": FunctionFragment;
    "deltas(address)": FunctionFragment;
    "dustThreshold()": FunctionFragment;
    "enteredMarkets(address,uint256)": FunctionFragment;
    "getAllMarkets()": FunctionFragment;
    "getEnteredMarkets(address)": FunctionFragment;
    "getHead(address,uint8)": FunctionFragment;
    "getNext(address,uint8,address)": FunctionFragment;
    "incentivesVault()": FunctionFragment;
    "initialize(address,address,address,(uint64,uint64,uint64,uint64),uint256,uint256,address,address)": FunctionFragment;
    "interestRatesManager()": FunctionFragment;
    "lastBorrowBlock(address)": FunctionFragment;
    "lastPoolIndexes(address)": FunctionFragment;
    "liquidate(address,address,address,uint256)": FunctionFragment;
    "marketParameters(address)": FunctionFragment;
    "marketStatus(address)": FunctionFragment;
    "marketPauseStatus(address)": FunctionFragment;
    "marketsCreated(uint256)": FunctionFragment;
    "maxSortedUsers()": FunctionFragment;
    "owner()": FunctionFragment;
    "p2pBorrowIndex(address)": FunctionFragment;
    "p2pDisabled(address)": FunctionFragment;
    "p2pSupplyIndex(address)": FunctionFragment;
    "positionsManager()": FunctionFragment;
    "renounceOwnership()": FunctionFragment;
    "repay(address,address,uint256)": FunctionFragment;
    "rewardsManager()": FunctionFragment;
    "setDefaultMaxGasForMatching((uint64,uint64,uint64,uint64))": FunctionFragment;
    "setDustThreshold(uint256)": FunctionFragment;
    "setIncentivesVault(address)": FunctionFragment;
    "setInterestRates(address)": FunctionFragment;
    "setIsBorrowPaused(address,bool)": FunctionFragment;
    "setIsClaimRewardsPaused(bool)": FunctionFragment;
    "setIsDeprecated(address,bool)": FunctionFragment;
    "setIsLiquidateBorrowPaused(address,bool)": FunctionFragment;
    "setIsLiquidateCollateralPaused(address,bool)": FunctionFragment;
    "setIsP2PDisabled(address,bool)": FunctionFragment;
    "setIsPausedForAllMarkets(bool)": FunctionFragment;
    "setIsRepayPaused(address,bool)": FunctionFragment;
    "setIsSupplyPaused(address,bool)": FunctionFragment;
    "setIsWithdrawPaused(address,bool)": FunctionFragment;
    "setMaxSortedUsers(uint256)": FunctionFragment;
    "setP2PIndexCursor(address,uint16)": FunctionFragment;
    "setPositionsManager(address)": FunctionFragment;
    "setReserveFactor(address,uint16)": FunctionFragment;
    "setRewardsManager(address)": FunctionFragment;
    "setTreasuryVault(address)": FunctionFragment;
    "supply(address,address,uint256)": FunctionFragment;
    "supply(address,address,uint256,uint256)": FunctionFragment;
    "supplyBalanceInOf(address,address)": FunctionFragment;
    "transferOwnership(address)": FunctionFragment;
    "treasuryVault()": FunctionFragment;
    "updateP2PIndexes(address)": FunctionFragment;
    "userMembership(address,address)": FunctionFragment;
    "wEth()": FunctionFragment;
    "withdraw(address,uint256)": FunctionFragment;
  };

  getFunction(
    nameOrSignatureOrTopic:
      | "CTOKEN_DECIMALS"
      | "MAX_BASIS_POINTS"
      | "MAX_CLAIMABLE_RESERVE"
      | "WAD"
      | "borrow(address,uint256)"
      | "borrow(address,uint256,uint256)"
      | "borrowBalanceInOf"
      | "cEth"
      | "claimRewards"
      | "claimToTreasury"
      | "comptroller"
      | "createMarket"
      | "defaultMaxGasForMatching"
      | "deltas"
      | "dustThreshold"
      | "enteredMarkets"
      | "getAllMarkets"
      | "getEnteredMarkets"
      | "getHead"
      | "getNext"
      | "incentivesVault"
      | "initialize"
      | "interestRatesManager"
      | "lastBorrowBlock"
      | "lastPoolIndexes"
      | "liquidate"
      | "marketParameters"
      | "marketStatus"
      | "marketPauseStatus"
      | "marketsCreated"
      | "maxSortedUsers"
      | "owner"
      | "p2pBorrowIndex"
      | "p2pDisabled"
      | "p2pSupplyIndex"
      | "positionsManager"
      | "renounceOwnership"
      | "repay"
      | "rewardsManager"
      | "setDefaultMaxGasForMatching"
      | "setDustThreshold"
      | "setIncentivesVault"
      | "setInterestRates"
      | "setIsBorrowPaused"
      | "setIsClaimRewardsPaused"
      | "setIsDeprecated"
      | "setIsLiquidateBorrowPaused"
      | "setIsLiquidateCollateralPaused"
      | "setIsP2PDisabled"
      | "setIsPausedForAllMarkets"
      | "setIsRepayPaused"
      | "setIsSupplyPaused"
      | "setIsWithdrawPaused"
      | "setMaxSortedUsers"
      | "setP2PIndexCursor"
      | "setPositionsManager"
      | "setReserveFactor"
      | "setRewardsManager"
      | "setTreasuryVault"
      | "supply(address,address,uint256)"
      | "supply(address,address,uint256,uint256)"
      | "supplyBalanceInOf"
      | "transferOwnership"
      | "treasuryVault"
      | "updateP2PIndexes"
      | "userMembership"
      | "wEth"
      | "withdraw"
  ): FunctionFragment;

  encodeFunctionData(
    functionFragment: "CTOKEN_DECIMALS",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "MAX_BASIS_POINTS",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "MAX_CLAIMABLE_RESERVE",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "WAD", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "borrow(address,uint256)",
    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "borrow(address,uint256,uint256)",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "borrowBalanceInOf",
    values: [PromiseOrValue<string>, PromiseOrValue<string>]
  ): string;
  encodeFunctionData(functionFragment: "cEth", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "claimRewards",
    values: [PromiseOrValue<string>[], PromiseOrValue<boolean>]
  ): string;
  encodeFunctionData(
    functionFragment: "claimToTreasury",
    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "comptroller",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "createMarket",
    values: [PromiseOrValue<string>, Types.MarketParametersStruct]
  ): string;
  encodeFunctionData(
    functionFragment: "defaultMaxGasForMatching",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "deltas",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "dustThreshold",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "enteredMarkets",
    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "getAllMarkets",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getEnteredMarkets",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "getHead",
    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "getNext",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<string>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "incentivesVault",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "initialize",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      Types.MaxGasForMatchingStruct,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<string>,
      PromiseOrValue<string>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "interestRatesManager",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "lastBorrowBlock",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "lastPoolIndexes",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "liquidate",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "marketParameters",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "marketStatus",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "marketPauseStatus",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "marketsCreated",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "maxSortedUsers",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "p2pBorrowIndex",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "p2pDisabled",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "p2pSupplyIndex",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "positionsManager",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "renounceOwnership",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "repay",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "rewardsManager",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "setDefaultMaxGasForMatching",
    values: [Types.MaxGasForMatchingStruct]
  ): string;
  encodeFunctionData(
    functionFragment: "setDustThreshold",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "setIncentivesVault",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "setInterestRates",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "setIsBorrowPaused",
    values: [PromiseOrValue<string>, PromiseOrValue<boolean>]
  ): string;
  encodeFunctionData(
    functionFragment: "setIsClaimRewardsPaused",
    values: [PromiseOrValue<boolean>]
  ): string;
  encodeFunctionData(
    functionFragment: "setIsDeprecated",
    values: [PromiseOrValue<string>, PromiseOrValue<boolean>]
  ): string;
  encodeFunctionData(
    functionFragment: "setIsLiquidateBorrowPaused",
    values: [PromiseOrValue<string>, PromiseOrValue<boolean>]
  ): string;
  encodeFunctionData(
    functionFragment: "setIsLiquidateCollateralPaused",
    values: [PromiseOrValue<string>, PromiseOrValue<boolean>]
  ): string;
  encodeFunctionData(
    functionFragment: "setIsP2PDisabled",
    values: [PromiseOrValue<string>, PromiseOrValue<boolean>]
  ): string;
  encodeFunctionData(
    functionFragment: "setIsPausedForAllMarkets",
    values: [PromiseOrValue<boolean>]
  ): string;
  encodeFunctionData(
    functionFragment: "setIsRepayPaused",
    values: [PromiseOrValue<string>, PromiseOrValue<boolean>]
  ): string;
  encodeFunctionData(
    functionFragment: "setIsSupplyPaused",
    values: [PromiseOrValue<string>, PromiseOrValue<boolean>]
  ): string;
  encodeFunctionData(
    functionFragment: "setIsWithdrawPaused",
    values: [PromiseOrValue<string>, PromiseOrValue<boolean>]
  ): string;
  encodeFunctionData(
    functionFragment: "setMaxSortedUsers",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "setP2PIndexCursor",
    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "setPositionsManager",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "setReserveFactor",
    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "setRewardsManager",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "setTreasuryVault",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "supply(address,address,uint256)",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "supply(address,address,uint256,uint256)",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "supplyBalanceInOf",
    values: [PromiseOrValue<string>, PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "transferOwnership",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "treasuryVault",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "updateP2PIndexes",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "userMembership",
    values: [PromiseOrValue<string>, PromiseOrValue<string>]
  ): string;
  encodeFunctionData(functionFragment: "wEth", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "withdraw",
    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
  ): string;

  decodeFunctionResult(
    functionFragment: "CTOKEN_DECIMALS",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "MAX_BASIS_POINTS",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "MAX_CLAIMABLE_RESERVE",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "WAD", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "borrow(address,uint256)",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "borrow(address,uint256,uint256)",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "borrowBalanceInOf",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "cEth", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "claimRewards",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "claimToTreasury",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "comptroller",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "createMarket",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "defaultMaxGasForMatching",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "deltas", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "dustThreshold",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "enteredMarkets",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getAllMarkets",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getEnteredMarkets",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "getHead", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "getNext", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "incentivesVault",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "interestRatesManager",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "lastBorrowBlock",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "lastPoolIndexes",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "liquidate", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "marketParameters",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "marketStatus",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "marketPauseStatus",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "marketsCreated",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "maxSortedUsers",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "p2pBorrowIndex",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "p2pDisabled",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "p2pSupplyIndex",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "positionsManager",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "renounceOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "repay", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "rewardsManager",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setDefaultMaxGasForMatching",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setDustThreshold",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setIncentivesVault",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setInterestRates",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setIsBorrowPaused",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setIsClaimRewardsPaused",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setIsDeprecated",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setIsLiquidateBorrowPaused",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setIsLiquidateCollateralPaused",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setIsP2PDisabled",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setIsPausedForAllMarkets",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setIsRepayPaused",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setIsSupplyPaused",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setIsWithdrawPaused",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setMaxSortedUsers",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setP2PIndexCursor",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setPositionsManager",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setReserveFactor",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setRewardsManager",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setTreasuryVault",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "supply(address,address,uint256)",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "supply(address,address,uint256,uint256)",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "supplyBalanceInOf",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "transferOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "treasuryVault",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateP2PIndexes",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "userMembership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "wEth", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;

  events: {
    "P2PIndexesUpdated(address,uint256,uint256,uint256,uint256)": EventFragment;
    "Borrowed(address,address,uint256,uint256,uint256)": EventFragment;
    "BorrowerPositionUpdated(address,address,uint256,uint256)": EventFragment;
    "Liquidated(address,address,address,uint256,address,uint256)": EventFragment;
    "P2PAmountsUpdated(address,uint256,uint256)": EventFragment;
    "P2PBorrowDeltaUpdated(address,uint256)": EventFragment;
    "P2PSupplyDeltaUpdated(address,uint256)": EventFragment;
    "Repaid(address,address,address,uint256,uint256,uint256)": EventFragment;
    "Supplied(address,address,address,uint256,uint256,uint256)": EventFragment;
    "SupplierPositionUpdated(address,address,uint256,uint256)": EventFragment;
    "P2PDeltasIncreased(address,uint256)": EventFragment;
    "Withdrawn(address,address,address,uint256,uint256,uint256)": EventFragment;
    "DefaultMaxGasForMatchingSet(tuple)": EventFragment;
    "DustThresholdSet(uint256)": EventFragment;
    "IncentivesVaultSet(address)": EventFragment;
    "InterestRatesSet(address)": EventFragment;
    "IsBorrowPausedSet(address,bool)": EventFragment;
    "IsDeprecatedSet(address,bool)": EventFragment;
    "IsLiquidateBorrowPausedSet(address,bool)": EventFragment;
    "IsLiquidateCollateralPausedSet(address,bool)": EventFragment;
    "IsRepayPausedSet(address,bool)": EventFragment;
    "IsSupplyPausedSet(address,bool)": EventFragment;
    "IsWithdrawPausedSet(address,bool)": EventFragment;
    "MarketCreated(address,uint16,uint16)": EventFragment;
    "MaxSortedUsersSet(uint256)": EventFragment;
    "OwnershipTransferred(address,address)": EventFragment;
    "P2PIndexCursorSet(address,uint16)": EventFragment;
    "P2PStatusSet(address,bool)": EventFragment;
    "PartialPauseStatusSet(address,bool)": EventFragment;
    "PauseStatusSet(address,bool)": EventFragment;
    "PositionsManagerSet(address)": EventFragment;
    "ReserveFactorSet(address,uint16)": EventFragment;
    "ReserveFeeClaimed(address,uint256)": EventFragment;
    "RewardsClaimed(address,uint256)": EventFragment;
    "RewardsClaimedAndTraded(address,uint256)": EventFragment;
    "RewardsManagerSet(address)": EventFragment;
    "TreasuryVaultSet(address)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "P2PIndexesUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Borrowed"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "BorrowerPositionUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Liquidated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "P2PAmountsUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "P2PBorrowDeltaUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "P2PSupplyDeltaUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Repaid"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Supplied"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SupplierPositionUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "P2PDeltasIncreased"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Withdrawn"): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "DefaultMaxGasForMatchingSet"
  ): EventFragment;
  getEvent(nameOrSignatureOrTopic: "DustThresholdSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "IncentivesVaultSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "InterestRatesSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "IsBorrowPausedSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "IsDeprecatedSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "IsLiquidateBorrowPausedSet"): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "IsLiquidateCollateralPausedSet"
  ): EventFragment;
  getEvent(nameOrSignatureOrTopic: "IsRepayPausedSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "IsSupplyPausedSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "IsWithdrawPausedSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "MarketCreated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "MaxSortedUsersSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "P2PIndexCursorSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "P2PStatusSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "PartialPauseStatusSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "PauseStatusSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "PositionsManagerSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ReserveFactorSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ReserveFeeClaimed"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RewardsClaimed"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RewardsClaimedAndTraded"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RewardsManagerSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "TreasuryVaultSet"): EventFragment;
}

export interface P2PIndexesUpdatedEventObject {
  _poolToken: string;
  _p2pSupplyIndex: BigNumber;
  _p2pBorrowIndex: BigNumber;
  _poolSupplyIndex: BigNumber;
  _poolBorrowIndex: BigNumber;
}
export type P2PIndexesUpdatedEvent = TypedEvent<
  [string, BigNumber, BigNumber, BigNumber, BigNumber],
  P2PIndexesUpdatedEventObject
>;

export type P2PIndexesUpdatedEventFilter =
  TypedEventFilter<P2PIndexesUpdatedEvent>;

export interface BorrowedEventObject {
  _borrower: string;
  _poolToken: string;
  _amount: BigNumber;
  _balanceOnPool: BigNumber;
  _balanceInP2P: BigNumber;
}
export type BorrowedEvent = TypedEvent<
  [string, string, BigNumber, BigNumber, BigNumber],
  BorrowedEventObject
>;

export type BorrowedEventFilter = TypedEventFilter<BorrowedEvent>;

export interface BorrowerPositionUpdatedEventObject {
  _user: string;
  _poolToken: string;
  _balanceOnPool: BigNumber;
  _balanceInP2P: BigNumber;
}
export type BorrowerPositionUpdatedEvent = TypedEvent<
  [string, string, BigNumber, BigNumber],
  BorrowerPositionUpdatedEventObject
>;

export type BorrowerPositionUpdatedEventFilter =
  TypedEventFilter<BorrowerPositionUpdatedEvent>;

export interface LiquidatedEventObject {
  _liquidator: string;
  _liquidated: string;
  _poolTokenBorrowedAddress: string;
  _amountRepaid: BigNumber;
  _poolTokenCollateralAddress: string;
  _amountSeized: BigNumber;
}
export type LiquidatedEvent = TypedEvent<
  [string, string, string, BigNumber, string, BigNumber],
  LiquidatedEventObject
>;

export type LiquidatedEventFilter = TypedEventFilter<LiquidatedEvent>;

export interface P2PAmountsUpdatedEventObject {
  _poolToken: string;
  _p2pSupplyAmount: BigNumber;
  _p2pBorrowAmount: BigNumber;
}
export type P2PAmountsUpdatedEvent = TypedEvent<
  [string, BigNumber, BigNumber],
  P2PAmountsUpdatedEventObject
>;

export type P2PAmountsUpdatedEventFilter =
  TypedEventFilter<P2PAmountsUpdatedEvent>;

export interface P2PBorrowDeltaUpdatedEventObject {
  _poolToken: string;
  _p2pBorrowDelta: BigNumber;
}
export type P2PBorrowDeltaUpdatedEvent = TypedEvent<
  [string, BigNumber],
  P2PBorrowDeltaUpdatedEventObject
>;

export type P2PBorrowDeltaUpdatedEventFilter =
  TypedEventFilter<P2PBorrowDeltaUpdatedEvent>;

export interface P2PSupplyDeltaUpdatedEventObject {
  _poolToken: string;
  _p2pSupplyDelta: BigNumber;
}
export type P2PSupplyDeltaUpdatedEvent = TypedEvent<
  [string, BigNumber],
  P2PSupplyDeltaUpdatedEventObject
>;

export type P2PSupplyDeltaUpdatedEventFilter =
  TypedEventFilter<P2PSupplyDeltaUpdatedEvent>;

export interface RepaidEventObject {
  _repayer: string;
  _onBehalf: string;
  _poolToken: string;
  _amount: BigNumber;
  _balanceOnPool: BigNumber;
  _balanceInP2P: BigNumber;
}
export type RepaidEvent = TypedEvent<
  [string, string, string, BigNumber, BigNumber, BigNumber],
  RepaidEventObject
>;

export type RepaidEventFilter = TypedEventFilter<RepaidEvent>;

export interface SuppliedEventObject {
  _supplier: string;
  _onBehalf: string;
  _poolToken: string;
  _amount: BigNumber;
  _balanceOnPool: BigNumber;
  _balanceInP2P: BigNumber;
}
export type SuppliedEvent = TypedEvent<
  [string, string, string, BigNumber, BigNumber, BigNumber],
  SuppliedEventObject
>;

export type SuppliedEventFilter = TypedEventFilter<SuppliedEvent>;

export interface SupplierPositionUpdatedEventObject {
  _user: string;
  _poolToken: string;
  _balanceOnPool: BigNumber;
  _balanceInP2P: BigNumber;
}
export type SupplierPositionUpdatedEvent = TypedEvent<
  [string, string, BigNumber, BigNumber],
  SupplierPositionUpdatedEventObject
>;

export type SupplierPositionUpdatedEventFilter =
  TypedEventFilter<SupplierPositionUpdatedEvent>;

export interface P2PDeltasIncreasedEventObject {
  _poolToken: string;
  _amount: BigNumber;
}
export type P2PDeltasIncreasedEvent = TypedEvent<
  [string, BigNumber],
  P2PDeltasIncreasedEventObject
>;

export type P2PDeltasIncreasedEventFilter =
  TypedEventFilter<P2PDeltasIncreasedEvent>;

export interface WithdrawnEventObject {
  _supplier: string;
  _receiver: string;
  _poolToken: string;
  _amount: BigNumber;
  _balanceOnPool: BigNumber;
  _balanceInP2P: BigNumber;
}
export type WithdrawnEvent = TypedEvent<
  [string, string, string, BigNumber, BigNumber, BigNumber],
  WithdrawnEventObject
>;

export type WithdrawnEventFilter = TypedEventFilter<WithdrawnEvent>;

export interface DefaultMaxGasForMatchingSetEventObject {
  _defaultMaxGasForMatching: Types.MaxGasForMatchingStructOutput;
}
export type DefaultMaxGasForMatchingSetEvent = TypedEvent<
  [Types.MaxGasForMatchingStructOutput],
  DefaultMaxGasForMatchingSetEventObject
>;

export type DefaultMaxGasForMatchingSetEventFilter =
  TypedEventFilter<DefaultMaxGasForMatchingSetEvent>;

export interface DustThresholdSetEventObject {
  _dustThreshold: BigNumber;
}
export type DustThresholdSetEvent = TypedEvent<
  [BigNumber],
  DustThresholdSetEventObject
>;

export type DustThresholdSetEventFilter =
  TypedEventFilter<DustThresholdSetEvent>;

export interface IncentivesVaultSetEventObject {
  _newIncentivesVaultAddress: string;
}
export type IncentivesVaultSetEvent = TypedEvent<
  [string],
  IncentivesVaultSetEventObject
>;

export type IncentivesVaultSetEventFilter =
  TypedEventFilter<IncentivesVaultSetEvent>;

export interface InterestRatesSetEventObject {
  _interestRatesManager: string;
}
export type InterestRatesSetEvent = TypedEvent<
  [string],
  InterestRatesSetEventObject
>;

export type InterestRatesSetEventFilter =
  TypedEventFilter<InterestRatesSetEvent>;

export interface IsBorrowPausedSetEventObject {
  _poolToken: string;
  _isPaused: boolean;
}
export type IsBorrowPausedSetEvent = TypedEvent<
  [string, boolean],
  IsBorrowPausedSetEventObject
>;

export type IsBorrowPausedSetEventFilter =
  TypedEventFilter<IsBorrowPausedSetEvent>;

export interface IsDeprecatedSetEventObject {
  _poolToken: string;
  _isDeprecated: boolean;
}
export type IsDeprecatedSetEvent = TypedEvent<
  [string, boolean],
  IsDeprecatedSetEventObject
>;

export type IsDeprecatedSetEventFilter = TypedEventFilter<IsDeprecatedSetEvent>;

export interface IsLiquidateBorrowPausedSetEventObject {
  _poolToken: string;
  _isPaused: boolean;
}
export type IsLiquidateBorrowPausedSetEvent = TypedEvent<
  [string, boolean],
  IsLiquidateBorrowPausedSetEventObject
>;

export type IsLiquidateBorrowPausedSetEventFilter =
  TypedEventFilter<IsLiquidateBorrowPausedSetEvent>;

export interface IsLiquidateCollateralPausedSetEventObject {
  _poolToken: string;
  _isPaused: boolean;
}
export type IsLiquidateCollateralPausedSetEvent = TypedEvent<
  [string, boolean],
  IsLiquidateCollateralPausedSetEventObject
>;

export type IsLiquidateCollateralPausedSetEventFilter =
  TypedEventFilter<IsLiquidateCollateralPausedSetEvent>;

export interface IsRepayPausedSetEventObject {
  _poolToken: string;
  _isPaused: boolean;
}
export type IsRepayPausedSetEvent = TypedEvent<
  [string, boolean],
  IsRepayPausedSetEventObject
>;

export type IsRepayPausedSetEventFilter =
  TypedEventFilter<IsRepayPausedSetEvent>;

export interface IsSupplyPausedSetEventObject {
  _poolToken: string;
  _isPaused: boolean;
}
export type IsSupplyPausedSetEvent = TypedEvent<
  [string, boolean],
  IsSupplyPausedSetEventObject
>;

export type IsSupplyPausedSetEventFilter =
  TypedEventFilter<IsSupplyPausedSetEvent>;

export interface IsWithdrawPausedSetEventObject {
  _poolToken: string;
  _isPaused: boolean;
}
export type IsWithdrawPausedSetEvent = TypedEvent<
  [string, boolean],
  IsWithdrawPausedSetEventObject
>;

export type IsWithdrawPausedSetEventFilter =
  TypedEventFilter<IsWithdrawPausedSetEvent>;

export interface MarketCreatedEventObject {
  _poolToken: string;
  _reserveFactor: number;
  _p2pIndexCursor: number;
}
export type MarketCreatedEvent = TypedEvent<
  [string, number, number],
  MarketCreatedEventObject
>;

export type MarketCreatedEventFilter = TypedEventFilter<MarketCreatedEvent>;

export interface MaxSortedUsersSetEventObject {
  _newValue: BigNumber;
}
export type MaxSortedUsersSetEvent = TypedEvent<
  [BigNumber],
  MaxSortedUsersSetEventObject
>;

export type MaxSortedUsersSetEventFilter =
  TypedEventFilter<MaxSortedUsersSetEvent>;

export interface OwnershipTransferredEventObject {
  previousOwner: string;
  newOwner: string;
}
export type OwnershipTransferredEvent = TypedEvent<
  [string, string],
  OwnershipTransferredEventObject
>;

export type OwnershipTransferredEventFilter =
  TypedEventFilter<OwnershipTransferredEvent>;

export interface P2PIndexCursorSetEventObject {
  _poolToken: string;
  _newValue: number;
}
export type P2PIndexCursorSetEvent = TypedEvent<
  [string, number],
  P2PIndexCursorSetEventObject
>;

export type P2PIndexCursorSetEventFilter =
  TypedEventFilter<P2PIndexCursorSetEvent>;

export interface P2PStatusSetEventObject {
  _poolToken: string;
  _isP2PDisabled: boolean;
}
export type P2PStatusSetEvent = TypedEvent<
  [string, boolean],
  P2PStatusSetEventObject
>;

export type P2PStatusSetEventFilter = TypedEventFilter<P2PStatusSetEvent>;

export interface PartialPauseStatusSetEventObject {
  _poolToken: string;
  _newStatus: boolean;
}
export type PartialPauseStatusSetEvent = TypedEvent<
  [string, boolean],
  PartialPauseStatusSetEventObject
>;

export type PartialPauseStatusSetEventFilter =
  TypedEventFilter<PartialPauseStatusSetEvent>;

export interface PauseStatusSetEventObject {
  _poolToken: string;
  _newStatus: boolean;
}
export type PauseStatusSetEvent = TypedEvent<
  [string, boolean],
  PauseStatusSetEventObject
>;

export type PauseStatusSetEventFilter = TypedEventFilter<PauseStatusSetEvent>;

export interface PositionsManagerSetEventObject {
  _positionsManager: string;
}
export type PositionsManagerSetEvent = TypedEvent<
  [string],
  PositionsManagerSetEventObject
>;

export type PositionsManagerSetEventFilter =
  TypedEventFilter<PositionsManagerSetEvent>;

export interface ReserveFactorSetEventObject {
  _poolToken: string;
  _newValue: number;
}
export type ReserveFactorSetEvent = TypedEvent<
  [string, number],
  ReserveFactorSetEventObject
>;

export type ReserveFactorSetEventFilter =
  TypedEventFilter<ReserveFactorSetEvent>;

export interface ReserveFeeClaimedEventObject {
  _poolToken: string;
  _amountClaimed: BigNumber;
}
export type ReserveFeeClaimedEvent = TypedEvent<
  [string, BigNumber],
  ReserveFeeClaimedEventObject
>;

export type ReserveFeeClaimedEventFilter =
  TypedEventFilter<ReserveFeeClaimedEvent>;

export interface RewardsClaimedEventObject {
  _user: string;
  _amountClaimed: BigNumber;
}
export type RewardsClaimedEvent = TypedEvent<
  [string, BigNumber],
  RewardsClaimedEventObject
>;

export type RewardsClaimedEventFilter = TypedEventFilter<RewardsClaimedEvent>;

export interface RewardsClaimedAndTradedEventObject {
  _user: string;
  _amountSent: BigNumber;
}
export type RewardsClaimedAndTradedEvent = TypedEvent<
  [string, BigNumber],
  RewardsClaimedAndTradedEventObject
>;

export type RewardsClaimedAndTradedEventFilter =
  TypedEventFilter<RewardsClaimedAndTradedEvent>;

export interface RewardsManagerSetEventObject {
  _newRewardsManagerAddress: string;
}
export type RewardsManagerSetEvent = TypedEvent<
  [string],
  RewardsManagerSetEventObject
>;

export type RewardsManagerSetEventFilter =
  TypedEventFilter<RewardsManagerSetEvent>;

export interface TreasuryVaultSetEventObject {
  _newTreasuryVaultAddress: string;
}
export type TreasuryVaultSetEvent = TypedEvent<
  [string],
  TreasuryVaultSetEventObject
>;

export type TreasuryVaultSetEventFilter =
  TypedEventFilter<TreasuryVaultSetEvent>;

export interface MorphoCompound extends BaseContract {
  connect(signerOrProvider: Signer | Provider | string): this;
  attach(addressOrName: string): this;
  deployed(): Promise<this>;

  interface: MorphoCompoundInterface;

  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: {
    CTOKEN_DECIMALS(overrides?: CallOverrides): Promise<[number]>;

    MAX_BASIS_POINTS(overrides?: CallOverrides): Promise<[number]>;

    MAX_CLAIMABLE_RESERVE(overrides?: CallOverrides): Promise<[number]>;

    WAD(overrides?: CallOverrides): Promise<[BigNumber]>;

    "borrow(address,uint256)"(
      _poolToken: PromiseOrValue<string>,
      _amount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    "borrow(address,uint256,uint256)"(
      _poolToken: PromiseOrValue<string>,
      _amount: PromiseOrValue<BigNumberish>,
      _maxGasForMatching: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    borrowBalanceInOf(
      arg0: PromiseOrValue<string>,
      arg1: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & { inP2P: BigNumber; onPool: BigNumber }
    >;

    cEth(overrides?: CallOverrides): Promise<[string]>;

    claimRewards(
      _cTokenAddresses: PromiseOrValue<string>[],
      _tradeForMorphoToken: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    claimToTreasury(
      _poolToken: PromiseOrValue<string>,
      _amount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    comptroller(overrides?: CallOverrides): Promise<[string]>;

    createMarket(
      _poolToken: PromiseOrValue<string>,
      _marketParams: Types.MarketParametersStruct,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    defaultMaxGasForMatching(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber, BigNumber] & {
        supply: BigNumber;
        borrow: BigNumber;
        withdraw: BigNumber;
        repay: BigNumber;
      }
    >;

    deltas(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber, BigNumber] & {
        p2pSupplyDelta: BigNumber;
        p2pBorrowDelta: BigNumber;
        p2pSupplyAmount: BigNumber;
        p2pBorrowAmount: BigNumber;
      }
    >;

    dustThreshold(overrides?: CallOverrides): Promise<[BigNumber]>;

    enteredMarkets(
      arg0: PromiseOrValue<string>,
      arg1: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[string]>;

    getAllMarkets(
      overrides?: CallOverrides
    ): Promise<[string[]] & { marketsCreated_: string[] }>;

    getEnteredMarkets(
      _user: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[string[]] & { enteredMarkets_: string[] }>;

    getHead(
      _poolToken: PromiseOrValue<string>,
      _positionType: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[string] & { head: string }>;

    getNext(
      _poolToken: PromiseOrValue<string>,
      _positionType: PromiseOrValue<BigNumberish>,
      _user: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[string] & { next: string }>;

    incentivesVault(overrides?: CallOverrides): Promise<[string]>;

    initialize(
      _positionsManager: PromiseOrValue<string>,
      _interestRatesManager: PromiseOrValue<string>,
      _comptroller: PromiseOrValue<string>,
      _defaultMaxGasForMatching: Types.MaxGasForMatchingStruct,
      _dustThreshold: PromiseOrValue<BigNumberish>,
      _maxSortedUsers: PromiseOrValue<BigNumberish>,
      _cEth: PromiseOrValue<string>,
      _wEth: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    interestRatesManager(overrides?: CallOverrides): Promise<[string]>;

    lastBorrowBlock(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    lastPoolIndexes(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<
      [number, BigNumber, BigNumber] & {
        lastUpdateBlockNumber: number;
        lastSupplyPoolIndex: BigNumber;
        lastBorrowPoolIndex: BigNumber;
      }
    >;

    liquidate(
      _poolTokenBorrowedAddress: PromiseOrValue<string>,
      _poolTokenCollateralAddress: PromiseOrValue<string>,
      _borrower: PromiseOrValue<string>,
      _amount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    marketParameters(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<
      [number, number] & { reserveFactor: number; p2pIndexCursor: number }
    >;

    marketStatus(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<
      [boolean, boolean, boolean] & {
        isCreated: boolean;
        isPaused: boolean;
        isPartiallyPaused: boolean;
      }
    >;

    marketPauseStatus(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<
      [boolean, boolean, boolean, boolean, boolean, boolean, boolean] & {
        isSupplyPaused: boolean;
        isBorrowPaused: boolean;
        isWithdrawPaused: boolean;
        isRepayPaused: boolean;
        isLiquidateCollateralPaused: boolean;
        isLiquidateBorrowPaused: boolean;
        isDeprecated: boolean;
      }
    >;

    marketsCreated(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[string]>;

    maxSortedUsers(overrides?: CallOverrides): Promise<[BigNumber]>;

    owner(overrides?: CallOverrides): Promise<[string]>;

    p2pBorrowIndex(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    p2pDisabled(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    p2pSupplyIndex(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    positionsManager(overrides?: CallOverrides): Promise<[string]>;

    renounceOwnership(
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    repay(
      _poolToken: PromiseOrValue<string>,
      _onBehalf: PromiseOrValue<string>,
      _amount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    rewardsManager(overrides?: CallOverrides): Promise<[string]>;

    setDefaultMaxGasForMatching(
      _defaultMaxGasForMatching: Types.MaxGasForMatchingStruct,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setDustThreshold(
      _dustThreshold: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setIncentivesVault(
      _incentivesVault: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setInterestRates(
      _interestRatesManager: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setIsBorrowPaused(
      _poolToken: PromiseOrValue<string>,
      _isPaused: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setIsClaimRewardsPaused(
      _isPaused: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setIsDeprecated(
      _poolToken: PromiseOrValue<string>,
      _isDeprecated: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setIsLiquidateBorrowPaused(
      _poolToken: PromiseOrValue<string>,
      _isPaused: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setIsLiquidateCollateralPaused(
      _poolToken: PromiseOrValue<string>,
      _isPaused: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setIsP2PDisabled(
      _poolToken: PromiseOrValue<string>,
      _isP2PDisabled: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setIsPausedForAllMarkets(
      _isPaused: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setIsRepayPaused(
      _poolToken: PromiseOrValue<string>,
      _isPaused: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setIsSupplyPaused(
      _poolToken: PromiseOrValue<string>,
      _isPaused: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setIsWithdrawPaused(
      _poolToken: PromiseOrValue<string>,
      _isPaused: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setMaxSortedUsers(
      _newMaxSortedUsers: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setP2PIndexCursor(
      _poolToken: PromiseOrValue<string>,
      _p2pIndexCursor: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setPositionsManager(
      _positionsManager: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setReserveFactor(
      _poolToken: PromiseOrValue<string>,
      _newReserveFactor: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setRewardsManager(
      _rewardsManager: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setTreasuryVault(
      _treasuryVault: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    "supply(address,address,uint256)"(
      _poolToken: PromiseOrValue<string>,
      _onBehalf: PromiseOrValue<string>,
      _amount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    "supply(address,address,uint256,uint256)"(
      _poolToken: PromiseOrValue<string>,
      _onBehalf: PromiseOrValue<string>,
      _amount: PromiseOrValue<BigNumberish>,
      _maxGasForMatching: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    supplyBalanceInOf(
      arg0: PromiseOrValue<string>,
      arg1: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & { inP2P: BigNumber; onPool: BigNumber }
    >;

    transferOwnership(
      newOwner: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    treasuryVault(overrides?: CallOverrides): Promise<[string]>;

    updateP2PIndexes(
      _poolToken: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    userMembership(
      arg0: PromiseOrValue<string>,
      arg1: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    wEth(overrides?: CallOverrides): Promise<[string]>;

    withdraw(
      _poolToken: PromiseOrValue<string>,
      _amount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;
  };

  CTOKEN_DECIMALS(overrides?: CallOverrides): Promise<number>;

  MAX_BASIS_POINTS(overrides?: CallOverrides): Promise<number>;

  MAX_CLAIMABLE_RESERVE(overrides?: CallOverrides): Promise<number>;

  WAD(overrides?: CallOverrides): Promise<BigNumber>;

  "borrow(address,uint256)"(
    _poolToken: PromiseOrValue<string>,
    _amount: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  "borrow(address,uint256,uint256)"(
    _poolToken: PromiseOrValue<string>,
    _amount: PromiseOrValue<BigNumberish>,
    _maxGasForMatching: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  borrowBalanceInOf(
    arg0: PromiseOrValue<string>,
    arg1: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<[BigNumber, BigNumber] & { inP2P: BigNumber; onPool: BigNumber }>;

  cEth(overrides?: CallOverrides): Promise<string>;

  claimRewards(
    _cTokenAddresses: PromiseOrValue<string>[],
    _tradeForMorphoToken: PromiseOrValue<boolean>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  claimToTreasury(
    _poolToken: PromiseOrValue<string>,
    _amount: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  comptroller(overrides?: CallOverrides): Promise<string>;

  createMarket(
    _poolToken: PromiseOrValue<string>,
    _marketParams: Types.MarketParametersStruct,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  defaultMaxGasForMatching(
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber, BigNumber, BigNumber] & {
      supply: BigNumber;
      borrow: BigNumber;
      withdraw: BigNumber;
      repay: BigNumber;
    }
  >;

  deltas(
    arg0: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber, BigNumber, BigNumber] & {
      p2pSupplyDelta: BigNumber;
      p2pBorrowDelta: BigNumber;
      p2pSupplyAmount: BigNumber;
      p2pBorrowAmount: BigNumber;
    }
  >;

  dustThreshold(overrides?: CallOverrides): Promise<BigNumber>;

  enteredMarkets(
    arg0: PromiseOrValue<string>,
    arg1: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<string>;

  getAllMarkets(overrides?: CallOverrides): Promise<string[]>;

  getEnteredMarkets(
    _user: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<string[]>;

  getHead(
    _poolToken: PromiseOrValue<string>,
    _positionType: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<string>;

  getNext(
    _poolToken: PromiseOrValue<string>,
    _positionType: PromiseOrValue<BigNumberish>,
    _user: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<string>;

  incentivesVault(overrides?: CallOverrides): Promise<string>;

  initialize(
    _positionsManager: PromiseOrValue<string>,
    _interestRatesManager: PromiseOrValue<string>,
    _comptroller: PromiseOrValue<string>,
    _defaultMaxGasForMatching: Types.MaxGasForMatchingStruct,
    _dustThreshold: PromiseOrValue<BigNumberish>,
    _maxSortedUsers: PromiseOrValue<BigNumberish>,
    _cEth: PromiseOrValue<string>,
    _wEth: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  interestRatesManager(overrides?: CallOverrides): Promise<string>;

  lastBorrowBlock(
    arg0: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  lastPoolIndexes(
    arg0: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<
    [number, BigNumber, BigNumber] & {
      lastUpdateBlockNumber: number;
      lastSupplyPoolIndex: BigNumber;
      lastBorrowPoolIndex: BigNumber;
    }
  >;

  liquidate(
    _poolTokenBorrowedAddress: PromiseOrValue<string>,
    _poolTokenCollateralAddress: PromiseOrValue<string>,
    _borrower: PromiseOrValue<string>,
    _amount: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  marketParameters(
    arg0: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<
    [number, number] & { reserveFactor: number; p2pIndexCursor: number }
  >;

  marketStatus(
    arg0: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<
    [boolean, boolean, boolean] & {
      isCreated: boolean;
      isPaused: boolean;
      isPartiallyPaused: boolean;
    }
  >;

  marketPauseStatus(
    arg0: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<
    [boolean, boolean, boolean, boolean, boolean, boolean, boolean] & {
      isSupplyPaused: boolean;
      isBorrowPaused: boolean;
      isWithdrawPaused: boolean;
      isRepayPaused: boolean;
      isLiquidateCollateralPaused: boolean;
      isLiquidateBorrowPaused: boolean;
      isDeprecated: boolean;
    }
  >;

  marketsCreated(
    arg0: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<string>;

  maxSortedUsers(overrides?: CallOverrides): Promise<BigNumber>;

  owner(overrides?: CallOverrides): Promise<string>;

  p2pBorrowIndex(
    arg0: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  p2pDisabled(
    arg0: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<boolean>;

  p2pSupplyIndex(
    arg0: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  positionsManager(overrides?: CallOverrides): Promise<string>;

  renounceOwnership(
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  repay(
    _poolToken: PromiseOrValue<string>,
    _onBehalf: PromiseOrValue<string>,
    _amount: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  rewardsManager(overrides?: CallOverrides): Promise<string>;

  setDefaultMaxGasForMatching(
    _defaultMaxGasForMatching: Types.MaxGasForMatchingStruct,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setDustThreshold(
    _dustThreshold: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setIncentivesVault(
    _incentivesVault: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setInterestRates(
    _interestRatesManager: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setIsBorrowPaused(
    _poolToken: PromiseOrValue<string>,
    _isPaused: PromiseOrValue<boolean>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setIsClaimRewardsPaused(
    _isPaused: PromiseOrValue<boolean>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setIsDeprecated(
    _poolToken: PromiseOrValue<string>,
    _isDeprecated: PromiseOrValue<boolean>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setIsLiquidateBorrowPaused(
    _poolToken: PromiseOrValue<string>,
    _isPaused: PromiseOrValue<boolean>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setIsLiquidateCollateralPaused(
    _poolToken: PromiseOrValue<string>,
    _isPaused: PromiseOrValue<boolean>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setIsP2PDisabled(
    _poolToken: PromiseOrValue<string>,
    _isP2PDisabled: PromiseOrValue<boolean>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setIsPausedForAllMarkets(
    _isPaused: PromiseOrValue<boolean>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setIsRepayPaused(
    _poolToken: PromiseOrValue<string>,
    _isPaused: PromiseOrValue<boolean>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setIsSupplyPaused(
    _poolToken: PromiseOrValue<string>,
    _isPaused: PromiseOrValue<boolean>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setIsWithdrawPaused(
    _poolToken: PromiseOrValue<string>,
    _isPaused: PromiseOrValue<boolean>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setMaxSortedUsers(
    _newMaxSortedUsers: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setP2PIndexCursor(
    _poolToken: PromiseOrValue<string>,
    _p2pIndexCursor: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setPositionsManager(
    _positionsManager: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setReserveFactor(
    _poolToken: PromiseOrValue<string>,
    _newReserveFactor: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setRewardsManager(
    _rewardsManager: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setTreasuryVault(
    _treasuryVault: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  "supply(address,address,uint256)"(
    _poolToken: PromiseOrValue<string>,
    _onBehalf: PromiseOrValue<string>,
    _amount: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  "supply(address,address,uint256,uint256)"(
    _poolToken: PromiseOrValue<string>,
    _onBehalf: PromiseOrValue<string>,
    _amount: PromiseOrValue<BigNumberish>,
    _maxGasForMatching: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  supplyBalanceInOf(
    arg0: PromiseOrValue<string>,
    arg1: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<[BigNumber, BigNumber] & { inP2P: BigNumber; onPool: BigNumber }>;

  transferOwnership(
    newOwner: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  treasuryVault(overrides?: CallOverrides): Promise<string>;

  updateP2PIndexes(
    _poolToken: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  userMembership(
    arg0: PromiseOrValue<string>,
    arg1: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<boolean>;

  wEth(overrides?: CallOverrides): Promise<string>;

  withdraw(
    _poolToken: PromiseOrValue<string>,
    _amount: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  callStatic: {
    CTOKEN_DECIMALS(overrides?: CallOverrides): Promise<number>;

    MAX_BASIS_POINTS(overrides?: CallOverrides): Promise<number>;

    MAX_CLAIMABLE_RESERVE(overrides?: CallOverrides): Promise<number>;

    WAD(overrides?: CallOverrides): Promise<BigNumber>;

    "borrow(address,uint256)"(
      _poolToken: PromiseOrValue<string>,
      _amount: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    "borrow(address,uint256,uint256)"(
      _poolToken: PromiseOrValue<string>,
      _amount: PromiseOrValue<BigNumberish>,
      _maxGasForMatching: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    borrowBalanceInOf(
      arg0: PromiseOrValue<string>,
      arg1: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & { inP2P: BigNumber; onPool: BigNumber }
    >;

    cEth(overrides?: CallOverrides): Promise<string>;

    claimRewards(
      _cTokenAddresses: PromiseOrValue<string>[],
      _tradeForMorphoToken: PromiseOrValue<boolean>,
      overrides?: CallOverrides
    ): Promise<void>;

    claimToTreasury(
      _poolToken: PromiseOrValue<string>,
      _amount: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    comptroller(overrides?: CallOverrides): Promise<string>;

    createMarket(
      _poolToken: PromiseOrValue<string>,
      _marketParams: Types.MarketParametersStruct,
      overrides?: CallOverrides
    ): Promise<void>;

    defaultMaxGasForMatching(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber, BigNumber] & {
        supply: BigNumber;
        borrow: BigNumber;
        withdraw: BigNumber;
        repay: BigNumber;
      }
    >;

    deltas(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber, BigNumber] & {
        p2pSupplyDelta: BigNumber;
        p2pBorrowDelta: BigNumber;
        p2pSupplyAmount: BigNumber;
        p2pBorrowAmount: BigNumber;
      }
    >;

    dustThreshold(overrides?: CallOverrides): Promise<BigNumber>;

    enteredMarkets(
      arg0: PromiseOrValue<string>,
      arg1: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<string>;

    getAllMarkets(overrides?: CallOverrides): Promise<string[]>;

    getEnteredMarkets(
      _user: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<string[]>;

    getHead(
      _poolToken: PromiseOrValue<string>,
      _positionType: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<string>;

    getNext(
      _poolToken: PromiseOrValue<string>,
      _positionType: PromiseOrValue<BigNumberish>,
      _user: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<string>;

    incentivesVault(overrides?: CallOverrides): Promise<string>;

    initialize(
      _positionsManager: PromiseOrValue<string>,
      _interestRatesManager: PromiseOrValue<string>,
      _comptroller: PromiseOrValue<string>,
      _defaultMaxGasForMatching: Types.MaxGasForMatchingStruct,
      _dustThreshold: PromiseOrValue<BigNumberish>,
      _maxSortedUsers: PromiseOrValue<BigNumberish>,
      _cEth: PromiseOrValue<string>,
      _wEth: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    interestRatesManager(overrides?: CallOverrides): Promise<string>;

    lastBorrowBlock(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    lastPoolIndexes(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<
      [number, BigNumber, BigNumber] & {
        lastUpdateBlockNumber: number;
        lastSupplyPoolIndex: BigNumber;
        lastBorrowPoolIndex: BigNumber;
      }
    >;

    liquidate(
      _poolTokenBorrowedAddress: PromiseOrValue<string>,
      _poolTokenCollateralAddress: PromiseOrValue<string>,
      _borrower: PromiseOrValue<string>,
      _amount: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    marketParameters(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<
      [number, number] & { reserveFactor: number; p2pIndexCursor: number }
    >;

    marketStatus(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<
      [boolean, boolean, boolean] & {
        isCreated: boolean;
        isPaused: boolean;
        isPartiallyPaused: boolean;
      }
    >;

    marketPauseStatus(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<
      [boolean, boolean, boolean, boolean, boolean, boolean, boolean] & {
        isSupplyPaused: boolean;
        isBorrowPaused: boolean;
        isWithdrawPaused: boolean;
        isRepayPaused: boolean;
        isLiquidateCollateralPaused: boolean;
        isLiquidateBorrowPaused: boolean;
        isDeprecated: boolean;
      }
    >;

    marketsCreated(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<string>;

    maxSortedUsers(overrides?: CallOverrides): Promise<BigNumber>;

    owner(overrides?: CallOverrides): Promise<string>;

    p2pBorrowIndex(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    p2pDisabled(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<boolean>;

    p2pSupplyIndex(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    positionsManager(overrides?: CallOverrides): Promise<string>;

    renounceOwnership(overrides?: CallOverrides): Promise<void>;

    repay(
      _poolToken: PromiseOrValue<string>,
      _onBehalf: PromiseOrValue<string>,
      _amount: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    rewardsManager(overrides?: CallOverrides): Promise<string>;

    setDefaultMaxGasForMatching(
      _defaultMaxGasForMatching: Types.MaxGasForMatchingStruct,
      overrides?: CallOverrides
    ): Promise<void>;

    setDustThreshold(
      _dustThreshold: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    setIncentivesVault(
      _incentivesVault: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    setInterestRates(
      _interestRatesManager: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    setIsBorrowPaused(
      _poolToken: PromiseOrValue<string>,
      _isPaused: PromiseOrValue<boolean>,
      overrides?: CallOverrides
    ): Promise<void>;

    setIsClaimRewardsPaused(
      _isPaused: PromiseOrValue<boolean>,
      overrides?: CallOverrides
    ): Promise<void>;

    setIsDeprecated(
      _poolToken: PromiseOrValue<string>,
      _isDeprecated: PromiseOrValue<boolean>,
      overrides?: CallOverrides
    ): Promise<void>;

    setIsLiquidateBorrowPaused(
      _poolToken: PromiseOrValue<string>,
      _isPaused: PromiseOrValue<boolean>,
      overrides?: CallOverrides
    ): Promise<void>;

    setIsLiquidateCollateralPaused(
      _poolToken: PromiseOrValue<string>,
      _isPaused: PromiseOrValue<boolean>,
      overrides?: CallOverrides
    ): Promise<void>;

    setIsP2PDisabled(
      _poolToken: PromiseOrValue<string>,
      _isP2PDisabled: PromiseOrValue<boolean>,
      overrides?: CallOverrides
    ): Promise<void>;

    setIsPausedForAllMarkets(
      _isPaused: PromiseOrValue<boolean>,
      overrides?: CallOverrides
    ): Promise<void>;

    setIsRepayPaused(
      _poolToken: PromiseOrValue<string>,
      _isPaused: PromiseOrValue<boolean>,
      overrides?: CallOverrides
    ): Promise<void>;

    setIsSupplyPaused(
      _poolToken: PromiseOrValue<string>,
      _isPaused: PromiseOrValue<boolean>,
      overrides?: CallOverrides
    ): Promise<void>;

    setIsWithdrawPaused(
      _poolToken: PromiseOrValue<string>,
      _isPaused: PromiseOrValue<boolean>,
      overrides?: CallOverrides
    ): Promise<void>;

    setMaxSortedUsers(
      _newMaxSortedUsers: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    setP2PIndexCursor(
      _poolToken: PromiseOrValue<string>,
      _p2pIndexCursor: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    setPositionsManager(
      _positionsManager: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    setReserveFactor(
      _poolToken: PromiseOrValue<string>,
      _newReserveFactor: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    setRewardsManager(
      _rewardsManager: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    setTreasuryVault(
      _treasuryVault: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    "supply(address,address,uint256)"(
      _poolToken: PromiseOrValue<string>,
      _onBehalf: PromiseOrValue<string>,
      _amount: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    "supply(address,address,uint256,uint256)"(
      _poolToken: PromiseOrValue<string>,
      _onBehalf: PromiseOrValue<string>,
      _amount: PromiseOrValue<BigNumberish>,
      _maxGasForMatching: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    supplyBalanceInOf(
      arg0: PromiseOrValue<string>,
      arg1: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & { inP2P: BigNumber; onPool: BigNumber }
    >;

    transferOwnership(
      newOwner: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    treasuryVault(overrides?: CallOverrides): Promise<string>;

    updateP2PIndexes(
      _poolToken: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    userMembership(
      arg0: PromiseOrValue<string>,
      arg1: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<boolean>;

    wEth(overrides?: CallOverrides): Promise<string>;

    withdraw(
      _poolToken: PromiseOrValue<string>,
      _amount: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;
  };

  filters: {
    "P2PIndexesUpdated(address,uint256,uint256,uint256,uint256)"(
      _poolToken?: PromiseOrValue<string> | null,
      _p2pSupplyIndex?: null,
      _p2pBorrowIndex?: null,
      _poolSupplyIndex?: null,
      _poolBorrowIndex?: null
    ): P2PIndexesUpdatedEventFilter;
    P2PIndexesUpdated(
      _poolToken?: PromiseOrValue<string> | null,
      _p2pSupplyIndex?: null,
      _p2pBorrowIndex?: null,
      _poolSupplyIndex?: null,
      _poolBorrowIndex?: null
    ): P2PIndexesUpdatedEventFilter;

    "Borrowed(address,address,uint256,uint256,uint256)"(
      _borrower?: PromiseOrValue<string> | null,
      _poolToken?: PromiseOrValue<string> | null,
      _amount?: null,
      _balanceOnPool?: null,
      _balanceInP2P?: null
    ): BorrowedEventFilter;
    Borrowed(
      _borrower?: PromiseOrValue<string> | null,
      _poolToken?: PromiseOrValue<string> | null,
      _amount?: null,
      _balanceOnPool?: null,
      _balanceInP2P?: null
    ): BorrowedEventFilter;

    "BorrowerPositionUpdated(address,address,uint256,uint256)"(
      _user?: PromiseOrValue<string> | null,
      _poolToken?: PromiseOrValue<string> | null,
      _balanceOnPool?: null,
      _balanceInP2P?: null
    ): BorrowerPositionUpdatedEventFilter;
    BorrowerPositionUpdated(
      _user?: PromiseOrValue<string> | null,
      _poolToken?: PromiseOrValue<string> | null,
      _balanceOnPool?: null,
      _balanceInP2P?: null
    ): BorrowerPositionUpdatedEventFilter;

    "Liquidated(address,address,address,uint256,address,uint256)"(
      _liquidator?: null,
      _liquidated?: PromiseOrValue<string> | null,
      _poolTokenBorrowedAddress?: PromiseOrValue<string> | null,
      _amountRepaid?: null,
      _poolTokenCollateralAddress?: PromiseOrValue<string> | null,
      _amountSeized?: null
    ): LiquidatedEventFilter;
    Liquidated(
      _liquidator?: null,
      _liquidated?: PromiseOrValue<string> | null,
      _poolTokenBorrowedAddress?: PromiseOrValue<string> | null,
      _amountRepaid?: null,
      _poolTokenCollateralAddress?: PromiseOrValue<string> | null,
      _amountSeized?: null
    ): LiquidatedEventFilter;

    "P2PAmountsUpdated(address,uint256,uint256)"(
      _poolToken?: PromiseOrValue<string> | null,
      _p2pSupplyAmount?: null,
      _p2pBorrowAmount?: null
    ): P2PAmountsUpdatedEventFilter;
    P2PAmountsUpdated(
      _poolToken?: PromiseOrValue<string> | null,
      _p2pSupplyAmount?: null,
      _p2pBorrowAmount?: null
    ): P2PAmountsUpdatedEventFilter;

    "P2PBorrowDeltaUpdated(address,uint256)"(
      _poolToken?: PromiseOrValue<string> | null,
      _p2pBorrowDelta?: null
    ): P2PBorrowDeltaUpdatedEventFilter;
    P2PBorrowDeltaUpdated(
      _poolToken?: PromiseOrValue<string> | null,
      _p2pBorrowDelta?: null
    ): P2PBorrowDeltaUpdatedEventFilter;

    "P2PSupplyDeltaUpdated(address,uint256)"(
      _poolToken?: PromiseOrValue<string> | null,
      _p2pSupplyDelta?: null
    ): P2PSupplyDeltaUpdatedEventFilter;
    P2PSupplyDeltaUpdated(
      _poolToken?: PromiseOrValue<string> | null,
      _p2pSupplyDelta?: null
    ): P2PSupplyDeltaUpdatedEventFilter;

    "Repaid(address,address,address,uint256,uint256,uint256)"(
      _repayer?: PromiseOrValue<string> | null,
      _onBehalf?: PromiseOrValue<string> | null,
      _poolToken?: PromiseOrValue<string> | null,
      _amount?: null,
      _balanceOnPool?: null,
      _balanceInP2P?: null
    ): RepaidEventFilter;
    Repaid(
      _repayer?: PromiseOrValue<string> | null,
      _onBehalf?: PromiseOrValue<string> | null,
      _poolToken?: PromiseOrValue<string> | null,
      _amount?: null,
      _balanceOnPool?: null,
      _balanceInP2P?: null
    ): RepaidEventFilter;

    "Supplied(address,address,address,uint256,uint256,uint256)"(
      _supplier?: PromiseOrValue<string> | null,
      _onBehalf?: PromiseOrValue<string> | null,
      _poolToken?: PromiseOrValue<string> | null,
      _amount?: null,
      _balanceOnPool?: null,
      _balanceInP2P?: null
    ): SuppliedEventFilter;
    Supplied(
      _supplier?: PromiseOrValue<string> | null,
      _onBehalf?: PromiseOrValue<string> | null,
      _poolToken?: PromiseOrValue<string> | null,
      _amount?: null,
      _balanceOnPool?: null,
      _balanceInP2P?: null
    ): SuppliedEventFilter;

    "SupplierPositionUpdated(address,address,uint256,uint256)"(
      _user?: PromiseOrValue<string> | null,
      _poolToken?: PromiseOrValue<string> | null,
      _balanceOnPool?: null,
      _balanceInP2P?: null
    ): SupplierPositionUpdatedEventFilter;
    SupplierPositionUpdated(
      _user?: PromiseOrValue<string> | null,
      _poolToken?: PromiseOrValue<string> | null,
      _balanceOnPool?: null,
      _balanceInP2P?: null
    ): SupplierPositionUpdatedEventFilter;

    "P2PDeltasIncreased(address,uint256)"(
      _poolToken?: PromiseOrValue<string> | null,
      _amount?: null
    ): P2PDeltasIncreasedEventFilter;
    P2PDeltasIncreased(
      _poolToken?: PromiseOrValue<string> | null,
      _amount?: null
    ): P2PDeltasIncreasedEventFilter;

    "Withdrawn(address,address,address,uint256,uint256,uint256)"(
      _supplier?: PromiseOrValue<string> | null,
      _receiver?: PromiseOrValue<string> | null,
      _poolToken?: PromiseOrValue<string> | null,
      _amount?: null,
      _balanceOnPool?: null,
      _balanceInP2P?: null
    ): WithdrawnEventFilter;
    Withdrawn(
      _supplier?: PromiseOrValue<string> | null,
      _receiver?: PromiseOrValue<string> | null,
      _poolToken?: PromiseOrValue<string> | null,
      _amount?: null,
      _balanceOnPool?: null,
      _balanceInP2P?: null
    ): WithdrawnEventFilter;

    "DefaultMaxGasForMatchingSet(tuple)"(
      _defaultMaxGasForMatching?: null
    ): DefaultMaxGasForMatchingSetEventFilter;
    DefaultMaxGasForMatchingSet(
      _defaultMaxGasForMatching?: null
    ): DefaultMaxGasForMatchingSetEventFilter;

    "DustThresholdSet(uint256)"(
      _dustThreshold?: null
    ): DustThresholdSetEventFilter;
    DustThresholdSet(_dustThreshold?: null): DustThresholdSetEventFilter;

    "IncentivesVaultSet(address)"(
      _newIncentivesVaultAddress?: PromiseOrValue<string> | null
    ): IncentivesVaultSetEventFilter;
    IncentivesVaultSet(
      _newIncentivesVaultAddress?: PromiseOrValue<string> | null
    ): IncentivesVaultSetEventFilter;

    "InterestRatesSet(address)"(
      _interestRatesManager?: PromiseOrValue<string> | null
    ): InterestRatesSetEventFilter;
    InterestRatesSet(
      _interestRatesManager?: PromiseOrValue<string> | null
    ): InterestRatesSetEventFilter;

    "IsBorrowPausedSet(address,bool)"(
      _poolToken?: PromiseOrValue<string> | null,
      _isPaused?: null
    ): IsBorrowPausedSetEventFilter;
    IsBorrowPausedSet(
      _poolToken?: PromiseOrValue<string> | null,
      _isPaused?: null
    ): IsBorrowPausedSetEventFilter;

    "IsDeprecatedSet(address,bool)"(
      _poolToken?: PromiseOrValue<string> | null,
      _isDeprecated?: null
    ): IsDeprecatedSetEventFilter;
    IsDeprecatedSet(
      _poolToken?: PromiseOrValue<string> | null,
      _isDeprecated?: null
    ): IsDeprecatedSetEventFilter;

    "IsLiquidateBorrowPausedSet(address,bool)"(
      _poolToken?: PromiseOrValue<string> | null,
      _isPaused?: null
    ): IsLiquidateBorrowPausedSetEventFilter;
    IsLiquidateBorrowPausedSet(
      _poolToken?: PromiseOrValue<string> | null,
      _isPaused?: null
    ): IsLiquidateBorrowPausedSetEventFilter;

    "IsLiquidateCollateralPausedSet(address,bool)"(
      _poolToken?: PromiseOrValue<string> | null,
      _isPaused?: null
    ): IsLiquidateCollateralPausedSetEventFilter;
    IsLiquidateCollateralPausedSet(
      _poolToken?: PromiseOrValue<string> | null,
      _isPaused?: null
    ): IsLiquidateCollateralPausedSetEventFilter;

    "IsRepayPausedSet(address,bool)"(
      _poolToken?: PromiseOrValue<string> | null,
      _isPaused?: null
    ): IsRepayPausedSetEventFilter;
    IsRepayPausedSet(
      _poolToken?: PromiseOrValue<string> | null,
      _isPaused?: null
    ): IsRepayPausedSetEventFilter;

    "IsSupplyPausedSet(address,bool)"(
      _poolToken?: PromiseOrValue<string> | null,
      _isPaused?: null
    ): IsSupplyPausedSetEventFilter;
    IsSupplyPausedSet(
      _poolToken?: PromiseOrValue<string> | null,
      _isPaused?: null
    ): IsSupplyPausedSetEventFilter;

    "IsWithdrawPausedSet(address,bool)"(
      _poolToken?: PromiseOrValue<string> | null,
      _isPaused?: null
    ): IsWithdrawPausedSetEventFilter;
    IsWithdrawPausedSet(
      _poolToken?: PromiseOrValue<string> | null,
      _isPaused?: null
    ): IsWithdrawPausedSetEventFilter;

    "MarketCreated(address,uint16,uint16)"(
      _poolToken?: PromiseOrValue<string> | null,
      _reserveFactor?: null,
      _p2pIndexCursor?: null
    ): MarketCreatedEventFilter;
    MarketCreated(
      _poolToken?: PromiseOrValue<string> | null,
      _reserveFactor?: null,
      _p2pIndexCursor?: null
    ): MarketCreatedEventFilter;

    "MaxSortedUsersSet(uint256)"(
      _newValue?: null
    ): MaxSortedUsersSetEventFilter;
    MaxSortedUsersSet(_newValue?: null): MaxSortedUsersSetEventFilter;

    "OwnershipTransferred(address,address)"(
      previousOwner?: PromiseOrValue<string> | null,
      newOwner?: PromiseOrValue<string> | null
    ): OwnershipTransferredEventFilter;
    OwnershipTransferred(
      previousOwner?: PromiseOrValue<string> | null,
      newOwner?: PromiseOrValue<string> | null
    ): OwnershipTransferredEventFilter;

    "P2PIndexCursorSet(address,uint16)"(
      _poolToken?: PromiseOrValue<string> | null,
      _newValue?: null
    ): P2PIndexCursorSetEventFilter;
    P2PIndexCursorSet(
      _poolToken?: PromiseOrValue<string> | null,
      _newValue?: null
    ): P2PIndexCursorSetEventFilter;

    "P2PStatusSet(address,bool)"(
      _poolToken?: PromiseOrValue<string> | null,
      _isP2PDisabled?: null
    ): P2PStatusSetEventFilter;
    P2PStatusSet(
      _poolToken?: PromiseOrValue<string> | null,
      _isP2PDisabled?: null
    ): P2PStatusSetEventFilter;

    "PartialPauseStatusSet(address,bool)"(
      _poolToken?: PromiseOrValue<string> | null,
      _newStatus?: null
    ): PartialPauseStatusSetEventFilter;
    PartialPauseStatusSet(
      _poolToken?: PromiseOrValue<string> | null,
      _newStatus?: null
    ): PartialPauseStatusSetEventFilter;

    "PauseStatusSet(address,bool)"(
      _poolToken?: PromiseOrValue<string> | null,
      _newStatus?: null
    ): PauseStatusSetEventFilter;
    PauseStatusSet(
      _poolToken?: PromiseOrValue<string> | null,
      _newStatus?: null
    ): PauseStatusSetEventFilter;

    "PositionsManagerSet(address)"(
      _positionsManager?: PromiseOrValue<string> | null
    ): PositionsManagerSetEventFilter;
    PositionsManagerSet(
      _positionsManager?: PromiseOrValue<string> | null
    ): PositionsManagerSetEventFilter;

    "ReserveFactorSet(address,uint16)"(
      _poolToken?: PromiseOrValue<string> | null,
      _newValue?: null
    ): ReserveFactorSetEventFilter;
    ReserveFactorSet(
      _poolToken?: PromiseOrValue<string> | null,
      _newValue?: null
    ): ReserveFactorSetEventFilter;

    "ReserveFeeClaimed(address,uint256)"(
      _poolToken?: PromiseOrValue<string> | null,
      _amountClaimed?: null
    ): ReserveFeeClaimedEventFilter;
    ReserveFeeClaimed(
      _poolToken?: PromiseOrValue<string> | null,
      _amountClaimed?: null
    ): ReserveFeeClaimedEventFilter;

    "RewardsClaimed(address,uint256)"(
      _user?: PromiseOrValue<string> | null,
      _amountClaimed?: null
    ): RewardsClaimedEventFilter;
    RewardsClaimed(
      _user?: PromiseOrValue<string> | null,
      _amountClaimed?: null
    ): RewardsClaimedEventFilter;

    "RewardsClaimedAndTraded(address,uint256)"(
      _user?: PromiseOrValue<string> | null,
      _amountSent?: null
    ): RewardsClaimedAndTradedEventFilter;
    RewardsClaimedAndTraded(
      _user?: PromiseOrValue<string> | null,
      _amountSent?: null
    ): RewardsClaimedAndTradedEventFilter;

    "RewardsManagerSet(address)"(
      _newRewardsManagerAddress?: PromiseOrValue<string> | null
    ): RewardsManagerSetEventFilter;
    RewardsManagerSet(
      _newRewardsManagerAddress?: PromiseOrValue<string> | null
    ): RewardsManagerSetEventFilter;

    "TreasuryVaultSet(address)"(
      _newTreasuryVaultAddress?: PromiseOrValue<string> | null
    ): TreasuryVaultSetEventFilter;
    TreasuryVaultSet(
      _newTreasuryVaultAddress?: PromiseOrValue<string> | null
    ): TreasuryVaultSetEventFilter;
  };

  estimateGas: {
    CTOKEN_DECIMALS(overrides?: CallOverrides): Promise<BigNumber>;

    MAX_BASIS_POINTS(overrides?: CallOverrides): Promise<BigNumber>;

    MAX_CLAIMABLE_RESERVE(overrides?: CallOverrides): Promise<BigNumber>;

    WAD(overrides?: CallOverrides): Promise<BigNumber>;

    "borrow(address,uint256)"(
      _poolToken: PromiseOrValue<string>,
      _amount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    "borrow(address,uint256,uint256)"(
      _poolToken: PromiseOrValue<string>,
      _amount: PromiseOrValue<BigNumberish>,
      _maxGasForMatching: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    borrowBalanceInOf(
      arg0: PromiseOrValue<string>,
      arg1: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    cEth(overrides?: CallOverrides): Promise<BigNumber>;

    claimRewards(
      _cTokenAddresses: PromiseOrValue<string>[],
      _tradeForMorphoToken: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    claimToTreasury(
      _poolToken: PromiseOrValue<string>,
      _amount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    comptroller(overrides?: CallOverrides): Promise<BigNumber>;

    createMarket(
      _poolToken: PromiseOrValue<string>,
      _marketParams: Types.MarketParametersStruct,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    defaultMaxGasForMatching(overrides?: CallOverrides): Promise<BigNumber>;

    deltas(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    dustThreshold(overrides?: CallOverrides): Promise<BigNumber>;

    enteredMarkets(
      arg0: PromiseOrValue<string>,
      arg1: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getAllMarkets(overrides?: CallOverrides): Promise<BigNumber>;

    getEnteredMarkets(
      _user: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getHead(
      _poolToken: PromiseOrValue<string>,
      _positionType: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getNext(
      _poolToken: PromiseOrValue<string>,
      _positionType: PromiseOrValue<BigNumberish>,
      _user: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    incentivesVault(overrides?: CallOverrides): Promise<BigNumber>;

    initialize(
      _positionsManager: PromiseOrValue<string>,
      _interestRatesManager: PromiseOrValue<string>,
      _comptroller: PromiseOrValue<string>,
      _defaultMaxGasForMatching: Types.MaxGasForMatchingStruct,
      _dustThreshold: PromiseOrValue<BigNumberish>,
      _maxSortedUsers: PromiseOrValue<BigNumberish>,
      _cEth: PromiseOrValue<string>,
      _wEth: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    interestRatesManager(overrides?: CallOverrides): Promise<BigNumber>;

    lastBorrowBlock(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    lastPoolIndexes(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    liquidate(
      _poolTokenBorrowedAddress: PromiseOrValue<string>,
      _poolTokenCollateralAddress: PromiseOrValue<string>,
      _borrower: PromiseOrValue<string>,
      _amount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    marketParameters(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    marketStatus(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    marketPauseStatus(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    marketsCreated(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    maxSortedUsers(overrides?: CallOverrides): Promise<BigNumber>;

    owner(overrides?: CallOverrides): Promise<BigNumber>;

    p2pBorrowIndex(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    p2pDisabled(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    p2pSupplyIndex(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    positionsManager(overrides?: CallOverrides): Promise<BigNumber>;

    renounceOwnership(
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    repay(
      _poolToken: PromiseOrValue<string>,
      _onBehalf: PromiseOrValue<string>,
      _amount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    rewardsManager(overrides?: CallOverrides): Promise<BigNumber>;

    setDefaultMaxGasForMatching(
      _defaultMaxGasForMatching: Types.MaxGasForMatchingStruct,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setDustThreshold(
      _dustThreshold: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setIncentivesVault(
      _incentivesVault: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setInterestRates(
      _interestRatesManager: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setIsBorrowPaused(
      _poolToken: PromiseOrValue<string>,
      _isPaused: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setIsClaimRewardsPaused(
      _isPaused: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setIsDeprecated(
      _poolToken: PromiseOrValue<string>,
      _isDeprecated: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setIsLiquidateBorrowPaused(
      _poolToken: PromiseOrValue<string>,
      _isPaused: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setIsLiquidateCollateralPaused(
      _poolToken: PromiseOrValue<string>,
      _isPaused: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setIsP2PDisabled(
      _poolToken: PromiseOrValue<string>,
      _isP2PDisabled: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setIsPausedForAllMarkets(
      _isPaused: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setIsRepayPaused(
      _poolToken: PromiseOrValue<string>,
      _isPaused: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setIsSupplyPaused(
      _poolToken: PromiseOrValue<string>,
      _isPaused: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setIsWithdrawPaused(
      _poolToken: PromiseOrValue<string>,
      _isPaused: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setMaxSortedUsers(
      _newMaxSortedUsers: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setP2PIndexCursor(
      _poolToken: PromiseOrValue<string>,
      _p2pIndexCursor: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setPositionsManager(
      _positionsManager: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setReserveFactor(
      _poolToken: PromiseOrValue<string>,
      _newReserveFactor: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setRewardsManager(
      _rewardsManager: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setTreasuryVault(
      _treasuryVault: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    "supply(address,address,uint256)"(
      _poolToken: PromiseOrValue<string>,
      _onBehalf: PromiseOrValue<string>,
      _amount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    "supply(address,address,uint256,uint256)"(
      _poolToken: PromiseOrValue<string>,
      _onBehalf: PromiseOrValue<string>,
      _amount: PromiseOrValue<BigNumberish>,
      _maxGasForMatching: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    supplyBalanceInOf(
      arg0: PromiseOrValue<string>,
      arg1: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    transferOwnership(
      newOwner: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    treasuryVault(overrides?: CallOverrides): Promise<BigNumber>;

    updateP2PIndexes(
      _poolToken: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    userMembership(
      arg0: PromiseOrValue<string>,
      arg1: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    wEth(overrides?: CallOverrides): Promise<BigNumber>;

    withdraw(
      _poolToken: PromiseOrValue<string>,
      _amount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;
  };

  populateTransaction: {
    CTOKEN_DECIMALS(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    MAX_BASIS_POINTS(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    MAX_CLAIMABLE_RESERVE(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    WAD(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    "borrow(address,uint256)"(
      _poolToken: PromiseOrValue<string>,
      _amount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    "borrow(address,uint256,uint256)"(
      _poolToken: PromiseOrValue<string>,
      _amount: PromiseOrValue<BigNumberish>,
      _maxGasForMatching: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    borrowBalanceInOf(
      arg0: PromiseOrValue<string>,
      arg1: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    cEth(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    claimRewards(
      _cTokenAddresses: PromiseOrValue<string>[],
      _tradeForMorphoToken: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    claimToTreasury(
      _poolToken: PromiseOrValue<string>,
      _amount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    comptroller(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    createMarket(
      _poolToken: PromiseOrValue<string>,
      _marketParams: Types.MarketParametersStruct,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    defaultMaxGasForMatching(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    deltas(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    dustThreshold(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    enteredMarkets(
      arg0: PromiseOrValue<string>,
      arg1: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getAllMarkets(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    getEnteredMarkets(
      _user: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getHead(
      _poolToken: PromiseOrValue<string>,
      _positionType: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getNext(
      _poolToken: PromiseOrValue<string>,
      _positionType: PromiseOrValue<BigNumberish>,
      _user: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    incentivesVault(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    initialize(
      _positionsManager: PromiseOrValue<string>,
      _interestRatesManager: PromiseOrValue<string>,
      _comptroller: PromiseOrValue<string>,
      _defaultMaxGasForMatching: Types.MaxGasForMatchingStruct,
      _dustThreshold: PromiseOrValue<BigNumberish>,
      _maxSortedUsers: PromiseOrValue<BigNumberish>,
      _cEth: PromiseOrValue<string>,
      _wEth: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    interestRatesManager(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    lastBorrowBlock(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    lastPoolIndexes(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    liquidate(
      _poolTokenBorrowedAddress: PromiseOrValue<string>,
      _poolTokenCollateralAddress: PromiseOrValue<string>,
      _borrower: PromiseOrValue<string>,
      _amount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    marketParameters(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    marketStatus(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    marketPauseStatus(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    marketsCreated(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    maxSortedUsers(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    p2pBorrowIndex(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    p2pDisabled(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    p2pSupplyIndex(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    positionsManager(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    renounceOwnership(
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    repay(
      _poolToken: PromiseOrValue<string>,
      _onBehalf: PromiseOrValue<string>,
      _amount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    rewardsManager(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    setDefaultMaxGasForMatching(
      _defaultMaxGasForMatching: Types.MaxGasForMatchingStruct,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setDustThreshold(
      _dustThreshold: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setIncentivesVault(
      _incentivesVault: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setInterestRates(
      _interestRatesManager: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setIsBorrowPaused(
      _poolToken: PromiseOrValue<string>,
      _isPaused: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setIsClaimRewardsPaused(
      _isPaused: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setIsDeprecated(
      _poolToken: PromiseOrValue<string>,
      _isDeprecated: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setIsLiquidateBorrowPaused(
      _poolToken: PromiseOrValue<string>,
      _isPaused: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setIsLiquidateCollateralPaused(
      _poolToken: PromiseOrValue<string>,
      _isPaused: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setIsP2PDisabled(
      _poolToken: PromiseOrValue<string>,
      _isP2PDisabled: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setIsPausedForAllMarkets(
      _isPaused: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setIsRepayPaused(
      _poolToken: PromiseOrValue<string>,
      _isPaused: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setIsSupplyPaused(
      _poolToken: PromiseOrValue<string>,
      _isPaused: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setIsWithdrawPaused(
      _poolToken: PromiseOrValue<string>,
      _isPaused: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setMaxSortedUsers(
      _newMaxSortedUsers: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setP2PIndexCursor(
      _poolToken: PromiseOrValue<string>,
      _p2pIndexCursor: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setPositionsManager(
      _positionsManager: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setReserveFactor(
      _poolToken: PromiseOrValue<string>,
      _newReserveFactor: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setRewardsManager(
      _rewardsManager: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setTreasuryVault(
      _treasuryVault: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    "supply(address,address,uint256)"(
      _poolToken: PromiseOrValue<string>,
      _onBehalf: PromiseOrValue<string>,
      _amount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    "supply(address,address,uint256,uint256)"(
      _poolToken: PromiseOrValue<string>,
      _onBehalf: PromiseOrValue<string>,
      _amount: PromiseOrValue<BigNumberish>,
      _maxGasForMatching: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    supplyBalanceInOf(
      arg0: PromiseOrValue<string>,
      arg1: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    transferOwnership(
      newOwner: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    treasuryVault(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    updateP2PIndexes(
      _poolToken: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    userMembership(
      arg0: PromiseOrValue<string>,
      arg1: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    wEth(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    withdraw(
      _poolToken: PromiseOrValue<string>,
      _amount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;
  };
}