/* 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 interface MorphoAaveV2Interface extends utils.Interface {
  functions: {
    "BORROWING_MASK()": FunctionFragment;
    "DEFAULT_LIQUIDATION_CLOSE_FACTOR()": FunctionFragment;
    "HEALTH_FACTOR_LIQUIDATION_THRESHOLD()": FunctionFragment;
    "MAX_BASIS_POINTS()": FunctionFragment;
    "MAX_NB_OF_MARKETS()": FunctionFragment;
    "NO_REFERRAL_CODE()": FunctionFragment;
    "ONE()": FunctionFragment;
    "ST_ETH()": FunctionFragment;
    "ST_ETH_BASE_REBASE_INDEX()": FunctionFragment;
    "VARIABLE_INTEREST_MODE()": FunctionFragment;
    "aaveIncentivesController()": FunctionFragment;
    "addressesProvider()": FunctionFragment;
    "borrow(address,uint256)": FunctionFragment;
    "borrow(address,uint256,uint256)": FunctionFragment;
    "borrowBalanceInOf(address,address)": FunctionFragment;
    "borrowMask(address)": FunctionFragment;
    "claimRewards(address[],bool)": FunctionFragment;
    "claimToTreasury(address[],uint256[])": FunctionFragment;
    "createMarket(address,uint16,uint16)": FunctionFragment;
    "defaultMaxGasForMatching()": FunctionFragment;
    "deltas(address)": FunctionFragment;
    "entryPositionsManager()": FunctionFragment;
    "exitPositionsManager()": FunctionFragment;
    "getHead(address,uint8)": FunctionFragment;
    "getMarketsCreated()": FunctionFragment;
    "getNext(address,uint8,address)": FunctionFragment;
    "incentivesVault()": FunctionFragment;
    "initialize(address,address,address,address,(uint64,uint64,uint64,uint64),uint256)": FunctionFragment;
    "interestRatesManager()": FunctionFragment;
    "isClaimRewardsPaused()": FunctionFragment;
    "liquidate(address,address,address,uint256)": FunctionFragment;
    "market(address)": FunctionFragment;
    "marketPauseStatus(address)": FunctionFragment;
    "maxSortedUsers()": FunctionFragment;
    "owner()": FunctionFragment;
    "p2pBorrowIndex(address)": FunctionFragment;
    "p2pSupplyIndex(address)": FunctionFragment;
    "pool()": FunctionFragment;
    "poolIndexes(address)": FunctionFragment;
    "renounceOwnership()": FunctionFragment;
    "repay(address,address,uint256)": FunctionFragment;
    "rewardsManager()": FunctionFragment;
    "setAaveIncentivesController(address)": FunctionFragment;
    "setAssetAsCollateral(address,bool)": FunctionFragment;
    "setDefaultMaxGasForMatching((uint64,uint64,uint64,uint64))": FunctionFragment;
    "setEntryPositionsManager(address)": FunctionFragment;
    "setExitPositionsManager(address)": FunctionFragment;
    "setIncentivesVault(address)": FunctionFragment;
    "setInterestRatesManager(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;
    "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;
    "updateIndexes(address)": FunctionFragment;
    "userMarkets(address)": FunctionFragment;
    "withdraw(address,uint256)": FunctionFragment;
  };

  getFunction(
    nameOrSignatureOrTopic:
      | "BORROWING_MASK"
      | "DEFAULT_LIQUIDATION_CLOSE_FACTOR"
      | "HEALTH_FACTOR_LIQUIDATION_THRESHOLD"
      | "MAX_BASIS_POINTS"
      | "MAX_NB_OF_MARKETS"
      | "NO_REFERRAL_CODE"
      | "ONE"
      | "ST_ETH"
      | "ST_ETH_BASE_REBASE_INDEX"
      | "VARIABLE_INTEREST_MODE"
      | "aaveIncentivesController"
      | "addressesProvider"
      | "borrow(address,uint256)"
      | "borrow(address,uint256,uint256)"
      | "borrowBalanceInOf"
      | "borrowMask"
      | "claimRewards"
      | "claimToTreasury"
      | "createMarket"
      | "defaultMaxGasForMatching"
      | "deltas"
      | "entryPositionsManager"
      | "exitPositionsManager"
      | "getHead"
      | "getMarketsCreated"
      | "getNext"
      | "incentivesVault"
      | "initialize"
      | "interestRatesManager"
      | "isClaimRewardsPaused"
      | "liquidate"
      | "market"
      | "marketPauseStatus"
      | "maxSortedUsers"
      | "owner"
      | "p2pBorrowIndex"
      | "p2pSupplyIndex"
      | "pool"
      | "poolIndexes"
      | "renounceOwnership"
      | "repay"
      | "rewardsManager"
      | "setAaveIncentivesController"
      | "setAssetAsCollateral"
      | "setDefaultMaxGasForMatching"
      | "setEntryPositionsManager"
      | "setExitPositionsManager"
      | "setIncentivesVault"
      | "setInterestRatesManager"
      | "setIsBorrowPaused"
      | "setIsClaimRewardsPaused"
      | "setIsDeprecated"
      | "setIsLiquidateBorrowPaused"
      | "setIsLiquidateCollateralPaused"
      | "setIsP2PDisabled"
      | "setIsPausedForAllMarkets"
      | "setIsRepayPaused"
      | "setIsSupplyPaused"
      | "setIsWithdrawPaused"
      | "setMaxSortedUsers"
      | "setP2PIndexCursor"
      | "setReserveFactor"
      | "setRewardsManager"
      | "setTreasuryVault"
      | "supply(address,address,uint256)"
      | "supply(address,address,uint256,uint256)"
      | "supplyBalanceInOf"
      | "transferOwnership"
      | "treasuryVault"
      | "updateIndexes"
      | "userMarkets"
      | "withdraw"
  ): FunctionFragment;

  encodeFunctionData(
    functionFragment: "BORROWING_MASK",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "DEFAULT_LIQUIDATION_CLOSE_FACTOR",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "HEALTH_FACTOR_LIQUIDATION_THRESHOLD",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "MAX_BASIS_POINTS",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "MAX_NB_OF_MARKETS",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "NO_REFERRAL_CODE",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "ONE", values?: undefined): string;
  encodeFunctionData(functionFragment: "ST_ETH", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "ST_ETH_BASE_REBASE_INDEX",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "VARIABLE_INTEREST_MODE",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "aaveIncentivesController",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "addressesProvider",
    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: "borrowMask",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "claimRewards",
    values: [PromiseOrValue<string>[], PromiseOrValue<boolean>]
  ): string;
  encodeFunctionData(
    functionFragment: "claimToTreasury",
    values: [PromiseOrValue<string>[], PromiseOrValue<BigNumberish>[]]
  ): string;
  encodeFunctionData(
    functionFragment: "createMarket",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "defaultMaxGasForMatching",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "deltas",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "entryPositionsManager",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "exitPositionsManager",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getHead",
    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "getMarketsCreated",
    values?: undefined
  ): 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>,
      PromiseOrValue<string>,
      Types.MaxGasForMatchingStruct,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "interestRatesManager",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "isClaimRewardsPaused",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "liquidate",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "market",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "marketPauseStatus",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "maxSortedUsers",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "p2pBorrowIndex",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "p2pSupplyIndex",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(functionFragment: "pool", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "poolIndexes",
    values: [PromiseOrValue<string>]
  ): 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: "setAaveIncentivesController",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "setAssetAsCollateral",
    values: [PromiseOrValue<string>, PromiseOrValue<boolean>]
  ): string;
  encodeFunctionData(
    functionFragment: "setDefaultMaxGasForMatching",
    values: [Types.MaxGasForMatchingStruct]
  ): string;
  encodeFunctionData(
    functionFragment: "setEntryPositionsManager",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "setExitPositionsManager",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "setIncentivesVault",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "setInterestRatesManager",
    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: "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: "updateIndexes",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "userMarkets",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "withdraw",
    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
  ): string;

  decodeFunctionResult(
    functionFragment: "BORROWING_MASK",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "DEFAULT_LIQUIDATION_CLOSE_FACTOR",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "HEALTH_FACTOR_LIQUIDATION_THRESHOLD",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "MAX_BASIS_POINTS",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "MAX_NB_OF_MARKETS",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "NO_REFERRAL_CODE",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "ONE", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "ST_ETH", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "ST_ETH_BASE_REBASE_INDEX",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "VARIABLE_INTEREST_MODE",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "aaveIncentivesController",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "addressesProvider",
    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: "borrowMask", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "claimRewards",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "claimToTreasury",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "createMarket",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "defaultMaxGasForMatching",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "deltas", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "entryPositionsManager",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "exitPositionsManager",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "getHead", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getMarketsCreated",
    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: "isClaimRewardsPaused",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "liquidate", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "market", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "marketPauseStatus",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "maxSortedUsers",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "p2pBorrowIndex",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "p2pSupplyIndex",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "pool", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "poolIndexes",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "renounceOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "repay", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "rewardsManager",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setAaveIncentivesController",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setAssetAsCollateral",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setDefaultMaxGasForMatching",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setEntryPositionsManager",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setExitPositionsManager",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setIncentivesVault",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setInterestRatesManager",
    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: "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: "updateIndexes",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "userMarkets",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;

  events: {
    "Borrowed(address,address,uint256,uint256,uint256)": EventFragment;
    "P2PAmountsUpdated(address,uint256,uint256)": EventFragment;
    "P2PBorrowDeltaUpdated(address,uint256)": EventFragment;
    "P2PSupplyDeltaUpdated(address,uint256)": EventFragment;
    "Supplied(address,address,address,uint256,uint256,uint256)": EventFragment;
    "BorrowerPositionUpdated(address,address,uint256,uint256)": EventFragment;
    "SupplierPositionUpdated(address,address,uint256,uint256)": EventFragment;
    "P2PIndexesUpdated(address,uint256,uint256,uint256,uint256)": EventFragment;
    "P2PDeltasIncreased(address,uint256)": EventFragment;
    "Liquidated(address,address,address,uint256,address,uint256)": EventFragment;
    "Withdrawn(address,address,address,uint256,uint256,uint256)": EventFragment;
    "Repaid(address,address,address,uint256,uint256,uint256)": EventFragment;
    "AaveIncentivesControllerSet(address)": EventFragment;
    "ClaimRewardsPauseStatusSet(bool)": EventFragment;
    "DefaultMaxGasForMatchingSet(tuple)": EventFragment;
    "EntryPositionsManagerSet(address)": EventFragment;
    "ExitPositionsManagerSet(address)": 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;
    "ReserveFactorSet(address,uint16)": EventFragment;
    "ReserveFeeClaimed(address,uint256)": EventFragment;
    "RewardsClaimed(address,uint256,bool)": EventFragment;
    "RewardsManagerSet(address)": EventFragment;
    "TreasuryVaultSet(address)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "Borrowed"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "P2PAmountsUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "P2PBorrowDeltaUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "P2PSupplyDeltaUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Supplied"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "BorrowerPositionUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SupplierPositionUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "P2PIndexesUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "P2PDeltasIncreased"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Liquidated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Withdrawn"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Repaid"): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "AaveIncentivesControllerSet"
  ): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ClaimRewardsPauseStatusSet"): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "DefaultMaxGasForMatchingSet"
  ): EventFragment;
  getEvent(nameOrSignatureOrTopic: "EntryPositionsManagerSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ExitPositionsManagerSet"): 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: "ReserveFactorSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ReserveFeeClaimed"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RewardsClaimed"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RewardsManagerSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "TreasuryVaultSet"): EventFragment;
}

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 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 SuppliedEventObject {
  _from: 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 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 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 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 P2PDeltasIncreasedEventObject {
  _poolToken: string;
  _amount: BigNumber;
}
export type P2PDeltasIncreasedEvent = TypedEvent<
  [string, BigNumber],
  P2PDeltasIncreasedEventObject
>;

export type P2PDeltasIncreasedEventFilter =
  TypedEventFilter<P2PDeltasIncreasedEvent>;

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

export type LiquidatedEventFilter = TypedEventFilter<LiquidatedEvent>;

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 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 AaveIncentivesControllerSetEventObject {
  _aaveIncentivesController: string;
}
export type AaveIncentivesControllerSetEvent = TypedEvent<
  [string],
  AaveIncentivesControllerSetEventObject
>;

export type AaveIncentivesControllerSetEventFilter =
  TypedEventFilter<AaveIncentivesControllerSetEvent>;

export interface ClaimRewardsPauseStatusSetEventObject {
  _newStatus: boolean;
}
export type ClaimRewardsPauseStatusSetEvent = TypedEvent<
  [boolean],
  ClaimRewardsPauseStatusSetEventObject
>;

export type ClaimRewardsPauseStatusSetEventFilter =
  TypedEventFilter<ClaimRewardsPauseStatusSetEvent>;

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

export type DefaultMaxGasForMatchingSetEventFilter =
  TypedEventFilter<DefaultMaxGasForMatchingSetEvent>;

export interface EntryPositionsManagerSetEventObject {
  _entryPositionsManager: string;
}
export type EntryPositionsManagerSetEvent = TypedEvent<
  [string],
  EntryPositionsManagerSetEventObject
>;

export type EntryPositionsManagerSetEventFilter =
  TypedEventFilter<EntryPositionsManagerSetEvent>;

export interface ExitPositionsManagerSetEventObject {
  _exitPositionsManager: string;
}
export type ExitPositionsManagerSetEvent = TypedEvent<
  [string],
  ExitPositionsManagerSetEventObject
>;

export type ExitPositionsManagerSetEventFilter =
  TypedEventFilter<ExitPositionsManagerSetEvent>;

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 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;
  _traded: boolean;
}
export type RewardsClaimedEvent = TypedEvent<
  [string, BigNumber, boolean],
  RewardsClaimedEventObject
>;

export type RewardsClaimedEventFilter = TypedEventFilter<RewardsClaimedEvent>;

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 MorphoAaveV2 extends BaseContract {
  connect(signerOrProvider: Signer | Provider | string): this;
  attach(addressOrName: string): this;
  deployed(): Promise<this>;

  interface: MorphoAaveV2Interface;

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

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

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

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

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

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

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

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

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

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

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

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

    "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 }
    >;

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

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

    claimToTreasury(
      _poolTokens: PromiseOrValue<string>[],
      _amounts: PromiseOrValue<BigNumberish>[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    createMarket(
      _underlyingToken: PromiseOrValue<string>,
      _reserveFactor: PromiseOrValue<BigNumberish>,
      _p2pIndexCursor: PromiseOrValue<BigNumberish>,
      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;
      }
    >;

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

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

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

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

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

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

    initialize(
      _entryPositionsManager: PromiseOrValue<string>,
      _exitPositionsManager: PromiseOrValue<string>,
      _interestRatesManager: PromiseOrValue<string>,
      _lendingPoolAddressesProvider: PromiseOrValue<string>,
      _defaultMaxGasForMatching: Types.MaxGasForMatchingStruct,
      _maxSortedUsers: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

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

    isClaimRewardsPaused(overrides?: CallOverrides): Promise<[boolean]>;

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

    market(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<
      [string, number, number, boolean, boolean, boolean, boolean] & {
        underlyingToken: string;
        reserveFactor: number;
        p2pIndexCursor: number;
        isCreated: boolean;
        isPaused: boolean;
        isPartiallyPaused: boolean;
        isP2PDisabled: 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;
      }
    >;

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

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

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

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

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

    poolIndexes(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<
      [number, BigNumber, BigNumber] & {
        lastUpdateTimestamp: number;
        poolSupplyIndex: BigNumber;
        poolBorrowIndex: BigNumber;
      }
    >;

    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]>;

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

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

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

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

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

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

    setInterestRatesManager(
      _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>;

    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]>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  "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 }>;

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

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

  claimToTreasury(
    _poolTokens: PromiseOrValue<string>[],
    _amounts: PromiseOrValue<BigNumberish>[],
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  createMarket(
    _underlyingToken: PromiseOrValue<string>,
    _reserveFactor: PromiseOrValue<BigNumberish>,
    _p2pIndexCursor: PromiseOrValue<BigNumberish>,
    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;
    }
  >;

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

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

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

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

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

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

  initialize(
    _entryPositionsManager: PromiseOrValue<string>,
    _exitPositionsManager: PromiseOrValue<string>,
    _interestRatesManager: PromiseOrValue<string>,
    _lendingPoolAddressesProvider: PromiseOrValue<string>,
    _defaultMaxGasForMatching: Types.MaxGasForMatchingStruct,
    _maxSortedUsers: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

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

  isClaimRewardsPaused(overrides?: CallOverrides): Promise<boolean>;

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

  market(
    arg0: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<
    [string, number, number, boolean, boolean, boolean, boolean] & {
      underlyingToken: string;
      reserveFactor: number;
      p2pIndexCursor: number;
      isCreated: boolean;
      isPaused: boolean;
      isPartiallyPaused: boolean;
      isP2PDisabled: 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;
    }
  >;

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

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

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

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

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

  poolIndexes(
    arg0: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<
    [number, BigNumber, BigNumber] & {
      lastUpdateTimestamp: number;
      poolSupplyIndex: BigNumber;
      poolBorrowIndex: BigNumber;
    }
  >;

  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>;

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

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

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

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

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

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

  setInterestRatesManager(
    _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>;

  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>;

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

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

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

  callStatic: {
    BORROWING_MASK(overrides?: CallOverrides): Promise<string>;

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

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

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

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

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

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

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

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

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

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

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

    "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 }
    >;

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

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

    claimToTreasury(
      _poolTokens: PromiseOrValue<string>[],
      _amounts: PromiseOrValue<BigNumberish>[],
      overrides?: CallOverrides
    ): Promise<void>;

    createMarket(
      _underlyingToken: PromiseOrValue<string>,
      _reserveFactor: PromiseOrValue<BigNumberish>,
      _p2pIndexCursor: PromiseOrValue<BigNumberish>,
      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;
      }
    >;

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

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

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

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

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

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

    initialize(
      _entryPositionsManager: PromiseOrValue<string>,
      _exitPositionsManager: PromiseOrValue<string>,
      _interestRatesManager: PromiseOrValue<string>,
      _lendingPoolAddressesProvider: PromiseOrValue<string>,
      _defaultMaxGasForMatching: Types.MaxGasForMatchingStruct,
      _maxSortedUsers: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

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

    isClaimRewardsPaused(overrides?: CallOverrides): Promise<boolean>;

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

    market(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<
      [string, number, number, boolean, boolean, boolean, boolean] & {
        underlyingToken: string;
        reserveFactor: number;
        p2pIndexCursor: number;
        isCreated: boolean;
        isPaused: boolean;
        isPartiallyPaused: boolean;
        isP2PDisabled: 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;
      }
    >;

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

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

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

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

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

    poolIndexes(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<
      [number, BigNumber, BigNumber] & {
        lastUpdateTimestamp: number;
        poolSupplyIndex: BigNumber;
        poolBorrowIndex: BigNumber;
      }
    >;

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

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

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

    setAaveIncentivesController(
      _aaveIncentivesController: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    setEntryPositionsManager(
      _entryPositionsManager: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    setExitPositionsManager(
      _exitPositionsManager: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

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

    setInterestRatesManager(
      _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>;

    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>;

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

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

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

  filters: {
    "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;

    "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;

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

    "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;

    "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;

    "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;

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

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

    "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;

    "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;

    "AaveIncentivesControllerSet(address)"(
      _aaveIncentivesController?: PromiseOrValue<string> | null
    ): AaveIncentivesControllerSetEventFilter;
    AaveIncentivesControllerSet(
      _aaveIncentivesController?: PromiseOrValue<string> | null
    ): AaveIncentivesControllerSetEventFilter;

    "ClaimRewardsPauseStatusSet(bool)"(
      _newStatus?: null
    ): ClaimRewardsPauseStatusSetEventFilter;
    ClaimRewardsPauseStatusSet(
      _newStatus?: null
    ): ClaimRewardsPauseStatusSetEventFilter;

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

    "EntryPositionsManagerSet(address)"(
      _entryPositionsManager?: PromiseOrValue<string> | null
    ): EntryPositionsManagerSetEventFilter;
    EntryPositionsManagerSet(
      _entryPositionsManager?: PromiseOrValue<string> | null
    ): EntryPositionsManagerSetEventFilter;

    "ExitPositionsManagerSet(address)"(
      _exitPositionsManager?: PromiseOrValue<string> | null
    ): ExitPositionsManagerSetEventFilter;
    ExitPositionsManagerSet(
      _exitPositionsManager?: PromiseOrValue<string> | null
    ): ExitPositionsManagerSetEventFilter;

    "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;

    "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,bool)"(
      _user?: PromiseOrValue<string> | null,
      _amountClaimed?: null,
      _traded?: PromiseOrValue<boolean> | null
    ): RewardsClaimedEventFilter;
    RewardsClaimed(
      _user?: PromiseOrValue<string> | null,
      _amountClaimed?: null,
      _traded?: PromiseOrValue<boolean> | null
    ): RewardsClaimedEventFilter;

    "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: {
    BORROWING_MASK(overrides?: CallOverrides): Promise<BigNumber>;

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

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

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

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

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

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

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

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

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

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

    addressesProvider(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>;

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

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

    claimToTreasury(
      _poolTokens: PromiseOrValue<string>[],
      _amounts: PromiseOrValue<BigNumberish>[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

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

    initialize(
      _entryPositionsManager: PromiseOrValue<string>,
      _exitPositionsManager: PromiseOrValue<string>,
      _interestRatesManager: PromiseOrValue<string>,
      _lendingPoolAddressesProvider: PromiseOrValue<string>,
      _defaultMaxGasForMatching: Types.MaxGasForMatchingStruct,
      _maxSortedUsers: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

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

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

    poolIndexes(
      arg0: PromiseOrValue<string>,
      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>;

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

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

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

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

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

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

    setInterestRatesManager(
      _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>;

    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>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    addressesProvider(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>;

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

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

    claimToTreasury(
      _poolTokens: PromiseOrValue<string>[],
      _amounts: PromiseOrValue<BigNumberish>[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

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

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

    initialize(
      _entryPositionsManager: PromiseOrValue<string>,
      _exitPositionsManager: PromiseOrValue<string>,
      _interestRatesManager: PromiseOrValue<string>,
      _lendingPoolAddressesProvider: PromiseOrValue<string>,
      _defaultMaxGasForMatching: Types.MaxGasForMatchingStruct,
      _maxSortedUsers: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

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

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

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

    poolIndexes(
      arg0: PromiseOrValue<string>,
      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>;

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

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

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

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

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

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

    setInterestRatesManager(
      _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>;

    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>;

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

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

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