/* Autogenerated file. Do not edit manually. */
/* tslint:disable */
/* eslint-disable */

import {
  ethers,
  EventFilter,
  Signer,
  BigNumber,
  BigNumberish,
  PopulatedTransaction,
  BaseContract,
  ContractTransaction,
  Overrides,
  CallOverrides,
} from "ethers";
import { BytesLike } from "@ethersproject/bytes";
import { Listener, Provider } from "@ethersproject/providers";
import { FunctionFragment, EventFragment, Result } from "@ethersproject/abi";
import type { TypedEventFilter, TypedEvent, TypedListener } from "./common";

interface ComptrollerInterface extends ethers.utils.Interface {
  functions: {
    "acceptOwnership()": FunctionFragment;
    "accessControlManager()": FunctionFragment;
    "accountAssets(address,uint256)": FunctionFragment;
    "actionPaused(address,uint8)": FunctionFragment;
    "addRewardsDistributor(address)": FunctionFragment;
    "allMarkets(uint256)": FunctionFragment;
    "approvedDelegates(address,address)": FunctionFragment;
    "borrowCaps(address)": FunctionFragment;
    "borrowVerify(address,address,uint256)": FunctionFragment;
    "checkMembership(address,address)": FunctionFragment;
    "closeFactorMantissa()": FunctionFragment;
    "enterMarkets(address[])": FunctionFragment;
    "exitMarket(address)": FunctionFragment;
    "getAccountLiquidity(address)": FunctionFragment;
    "getAllMarkets()": FunctionFragment;
    "getAssetsIn(address)": FunctionFragment;
    "getBorrowingPower(address)": FunctionFragment;
    "getHypotheticalAccountLiquidity(address,address,uint256,uint256)": FunctionFragment;
    "getRewardDistributors()": FunctionFragment;
    "getRewardsByMarket(address)": FunctionFragment;
    "healAccount(address)": FunctionFragment;
    "initialize(uint256,address)": FunctionFragment;
    "isComptroller()": FunctionFragment;
    "isForcedLiquidationEnabled(address)": FunctionFragment;
    "isMarketListed(address)": FunctionFragment;
    "liquidateAccount(address,tuple[])": FunctionFragment;
    "liquidateBorrowVerify(address,address,address,address,uint256,uint256)": FunctionFragment;
    "liquidateCalculateSeizeTokens(address,address,uint256)": FunctionFragment;
    "liquidationIncentiveMantissa()": FunctionFragment;
    "markets(address)": FunctionFragment;
    "maxLoopsLimit()": FunctionFragment;
    "minLiquidatableCollateral()": FunctionFragment;
    "mintVerify(address,address,uint256,uint256)": FunctionFragment;
    "oracle()": FunctionFragment;
    "owner()": FunctionFragment;
    "pendingOwner()": FunctionFragment;
    "poolRegistry()": FunctionFragment;
    "preBorrowHook(address,address,uint256)": FunctionFragment;
    "preLiquidateHook(address,address,address,uint256,bool)": FunctionFragment;
    "preMintHook(address,address,uint256)": FunctionFragment;
    "preRedeemHook(address,address,uint256)": FunctionFragment;
    "preRepayHook(address,address)": FunctionFragment;
    "preSeizeHook(address,address,address,address)": FunctionFragment;
    "preTransferHook(address,address,address,uint256)": FunctionFragment;
    "prime()": FunctionFragment;
    "redeemVerify(address,address,uint256,uint256)": FunctionFragment;
    "renounceOwnership()": FunctionFragment;
    "repayBorrowVerify(address,address,address,uint256,uint256)": FunctionFragment;
    "seizeVerify(address,address,address,address,uint256)": FunctionFragment;
    "setAccessControlManager(address)": FunctionFragment;
    "setActionsPaused(address[],uint8[],bool)": FunctionFragment;
    "setCloseFactor(uint256)": FunctionFragment;
    "setCollateralFactor(address,uint256,uint256)": FunctionFragment;
    "setForcedLiquidation(address,bool)": FunctionFragment;
    "setLiquidationIncentive(uint256)": FunctionFragment;
    "setMarketBorrowCaps(address[],uint256[])": FunctionFragment;
    "setMarketSupplyCaps(address[],uint256[])": FunctionFragment;
    "setMaxLoopsLimit(uint256)": FunctionFragment;
    "setMinLiquidatableCollateral(uint256)": FunctionFragment;
    "setPriceOracle(address)": FunctionFragment;
    "setPrimeToken(address)": FunctionFragment;
    "supplyCaps(address)": FunctionFragment;
    "supportMarket(address)": FunctionFragment;
    "transferOwnership(address)": FunctionFragment;
    "transferVerify(address,address,address,uint256)": FunctionFragment;
    "unlistMarket(address)": FunctionFragment;
    "updateDelegate(address,bool)": FunctionFragment;
    "updatePrices(address)": FunctionFragment;
  };

  encodeFunctionData(
    functionFragment: "acceptOwnership",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "accessControlManager",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "accountAssets",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "actionPaused",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "addRewardsDistributor",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "allMarkets",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "approvedDelegates",
    values: [string, string]
  ): string;
  encodeFunctionData(functionFragment: "borrowCaps", values: [string]): string;
  encodeFunctionData(
    functionFragment: "borrowVerify",
    values: [string, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "checkMembership",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "closeFactorMantissa",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "enterMarkets",
    values: [string[]]
  ): string;
  encodeFunctionData(functionFragment: "exitMarket", values: [string]): string;
  encodeFunctionData(
    functionFragment: "getAccountLiquidity",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "getAllMarkets",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "getAssetsIn", values: [string]): string;
  encodeFunctionData(
    functionFragment: "getBorrowingPower",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "getHypotheticalAccountLiquidity",
    values: [string, string, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getRewardDistributors",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getRewardsByMarket",
    values: [string]
  ): string;
  encodeFunctionData(functionFragment: "healAccount", values: [string]): string;
  encodeFunctionData(
    functionFragment: "initialize",
    values: [BigNumberish, string]
  ): string;
  encodeFunctionData(
    functionFragment: "isComptroller",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "isForcedLiquidationEnabled",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "isMarketListed",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "liquidateAccount",
    values: [
      string,
      {
        vTokenCollateral: string;
        vTokenBorrowed: string;
        repayAmount: BigNumberish;
      }[]
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "liquidateBorrowVerify",
    values: [string, string, string, string, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "liquidateCalculateSeizeTokens",
    values: [string, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "liquidationIncentiveMantissa",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "markets", values: [string]): string;
  encodeFunctionData(
    functionFragment: "maxLoopsLimit",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "minLiquidatableCollateral",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "mintVerify",
    values: [string, string, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "oracle", values?: undefined): string;
  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "pendingOwner",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "poolRegistry",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "preBorrowHook",
    values: [string, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "preLiquidateHook",
    values: [string, string, string, BigNumberish, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "preMintHook",
    values: [string, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "preRedeemHook",
    values: [string, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "preRepayHook",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "preSeizeHook",
    values: [string, string, string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "preTransferHook",
    values: [string, string, string, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "prime", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "redeemVerify",
    values: [string, string, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "renounceOwnership",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "repayBorrowVerify",
    values: [string, string, string, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "seizeVerify",
    values: [string, string, string, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setAccessControlManager",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setActionsPaused",
    values: [string[], BigNumberish[], boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "setCloseFactor",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setCollateralFactor",
    values: [string, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setForcedLiquidation",
    values: [string, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "setLiquidationIncentive",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setMarketBorrowCaps",
    values: [string[], BigNumberish[]]
  ): string;
  encodeFunctionData(
    functionFragment: "setMarketSupplyCaps",
    values: [string[], BigNumberish[]]
  ): string;
  encodeFunctionData(
    functionFragment: "setMaxLoopsLimit",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setMinLiquidatableCollateral",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setPriceOracle",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setPrimeToken",
    values: [string]
  ): string;
  encodeFunctionData(functionFragment: "supplyCaps", values: [string]): string;
  encodeFunctionData(
    functionFragment: "supportMarket",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "transferOwnership",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "transferVerify",
    values: [string, string, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "unlistMarket",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "updateDelegate",
    values: [string, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "updatePrices",
    values: [string]
  ): string;

  decodeFunctionResult(
    functionFragment: "acceptOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "accessControlManager",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "accountAssets",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "actionPaused",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "addRewardsDistributor",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "allMarkets", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "approvedDelegates",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "borrowCaps", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "borrowVerify",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "checkMembership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "closeFactorMantissa",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "enterMarkets",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "exitMarket", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getAccountLiquidity",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getAllMarkets",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getAssetsIn",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getBorrowingPower",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getHypotheticalAccountLiquidity",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getRewardDistributors",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getRewardsByMarket",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "healAccount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "isComptroller",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isForcedLiquidationEnabled",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isMarketListed",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "liquidateAccount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "liquidateBorrowVerify",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "liquidateCalculateSeizeTokens",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "liquidationIncentiveMantissa",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "markets", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "maxLoopsLimit",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "minLiquidatableCollateral",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "mintVerify", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "oracle", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "pendingOwner",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "poolRegistry",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "preBorrowHook",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "preLiquidateHook",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "preMintHook",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "preRedeemHook",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "preRepayHook",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "preSeizeHook",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "preTransferHook",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "prime", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "redeemVerify",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "renounceOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "repayBorrowVerify",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "seizeVerify",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setAccessControlManager",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setActionsPaused",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setCloseFactor",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setCollateralFactor",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setForcedLiquidation",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setLiquidationIncentive",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setMarketBorrowCaps",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setMarketSupplyCaps",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setMaxLoopsLimit",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setMinLiquidatableCollateral",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setPriceOracle",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setPrimeToken",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "supplyCaps", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "supportMarket",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "transferOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "transferVerify",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "unlistMarket",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateDelegate",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updatePrices",
    data: BytesLike
  ): Result;

  events: {
    "ActionPausedMarket(address,uint8,bool)": EventFragment;
    "DelegateUpdated(address,address,bool)": EventFragment;
    "Initialized(uint8)": EventFragment;
    "IsForcedLiquidationEnabledUpdated(address,bool)": EventFragment;
    "MarketEntered(address,address)": EventFragment;
    "MarketExited(address,address)": EventFragment;
    "MarketSupported(address)": EventFragment;
    "MarketUnlisted(address)": EventFragment;
    "MaxLoopsLimitUpdated(uint256,uint256)": EventFragment;
    "NewAccessControlManager(address,address)": EventFragment;
    "NewBorrowCap(address,uint256)": EventFragment;
    "NewCloseFactor(uint256,uint256)": EventFragment;
    "NewCollateralFactor(address,uint256,uint256)": EventFragment;
    "NewLiquidationIncentive(uint256,uint256)": EventFragment;
    "NewLiquidationThreshold(address,uint256,uint256)": EventFragment;
    "NewMinLiquidatableCollateral(uint256,uint256)": EventFragment;
    "NewPriceOracle(address,address)": EventFragment;
    "NewPrimeToken(address,address)": EventFragment;
    "NewRewardsDistributor(address,address)": EventFragment;
    "NewSupplyCap(address,uint256)": EventFragment;
    "OwnershipTransferStarted(address,address)": EventFragment;
    "OwnershipTransferred(address,address)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "ActionPausedMarket"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "DelegateUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "IsForcedLiquidationEnabledUpdated"
  ): EventFragment;
  getEvent(nameOrSignatureOrTopic: "MarketEntered"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "MarketExited"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "MarketSupported"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "MarketUnlisted"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "MaxLoopsLimitUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewAccessControlManager"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewBorrowCap"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewCloseFactor"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewCollateralFactor"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewLiquidationIncentive"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewLiquidationThreshold"): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "NewMinLiquidatableCollateral"
  ): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewPriceOracle"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewPrimeToken"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewRewardsDistributor"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewSupplyCap"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "OwnershipTransferStarted"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
}

export type ActionPausedMarketEvent = TypedEvent<
  [string, number, boolean] & {
    vToken: string;
    action: number;
    pauseState: boolean;
  }
>;

export type DelegateUpdatedEvent = TypedEvent<
  [string, string, boolean] & {
    approver: string;
    delegate: string;
    approved: boolean;
  }
>;

export type InitializedEvent = TypedEvent<[number] & { version: number }>;

export type IsForcedLiquidationEnabledUpdatedEvent = TypedEvent<
  [string, boolean] & { vToken: string; enable: boolean }
>;

export type MarketEnteredEvent = TypedEvent<
  [string, string] & { vToken: string; account: string }
>;

export type MarketExitedEvent = TypedEvent<
  [string, string] & { vToken: string; account: string }
>;

export type MarketSupportedEvent = TypedEvent<[string] & { vToken: string }>;

export type MarketUnlistedEvent = TypedEvent<[string] & { vToken: string }>;

export type MaxLoopsLimitUpdatedEvent = TypedEvent<
  [BigNumber, BigNumber] & {
    oldMaxLoopsLimit: BigNumber;
    newmaxLoopsLimit: BigNumber;
  }
>;

export type NewAccessControlManagerEvent = TypedEvent<
  [string, string] & {
    oldAccessControlManager: string;
    newAccessControlManager: string;
  }
>;

export type NewBorrowCapEvent = TypedEvent<
  [string, BigNumber] & { vToken: string; newBorrowCap: BigNumber }
>;

export type NewCloseFactorEvent = TypedEvent<
  [BigNumber, BigNumber] & {
    oldCloseFactorMantissa: BigNumber;
    newCloseFactorMantissa: BigNumber;
  }
>;

export type NewCollateralFactorEvent = TypedEvent<
  [string, BigNumber, BigNumber] & {
    vToken: string;
    oldCollateralFactorMantissa: BigNumber;
    newCollateralFactorMantissa: BigNumber;
  }
>;

export type NewLiquidationIncentiveEvent = TypedEvent<
  [BigNumber, BigNumber] & {
    oldLiquidationIncentiveMantissa: BigNumber;
    newLiquidationIncentiveMantissa: BigNumber;
  }
>;

export type NewLiquidationThresholdEvent = TypedEvent<
  [string, BigNumber, BigNumber] & {
    vToken: string;
    oldLiquidationThresholdMantissa: BigNumber;
    newLiquidationThresholdMantissa: BigNumber;
  }
>;

export type NewMinLiquidatableCollateralEvent = TypedEvent<
  [BigNumber, BigNumber] & {
    oldMinLiquidatableCollateral: BigNumber;
    newMinLiquidatableCollateral: BigNumber;
  }
>;

export type NewPriceOracleEvent = TypedEvent<
  [string, string] & { oldPriceOracle: string; newPriceOracle: string }
>;

export type NewPrimeTokenEvent = TypedEvent<
  [string, string] & { oldPrimeToken: string; newPrimeToken: string }
>;

export type NewRewardsDistributorEvent = TypedEvent<
  [string, string] & { rewardsDistributor: string; rewardToken: string }
>;

export type NewSupplyCapEvent = TypedEvent<
  [string, BigNumber] & { vToken: string; newSupplyCap: BigNumber }
>;

export type OwnershipTransferStartedEvent = TypedEvent<
  [string, string] & { previousOwner: string; newOwner: string }
>;

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

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

  listeners<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter?: TypedEventFilter<EventArgsArray, EventArgsObject>
  ): Array<TypedListener<EventArgsArray, EventArgsObject>>;
  off<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  on<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  once<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  removeListener<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  removeAllListeners<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>
  ): this;

  listeners(eventName?: string): Array<Listener>;
  off(eventName: string, listener: Listener): this;
  on(eventName: string, listener: Listener): this;
  once(eventName: string, listener: Listener): this;
  removeListener(eventName: string, listener: Listener): this;
  removeAllListeners(eventName?: string): this;

  queryFilter<EventArgsArray extends Array<any>, EventArgsObject>(
    event: TypedEventFilter<EventArgsArray, EventArgsObject>,
    fromBlockOrBlockhash?: string | number | undefined,
    toBlock?: string | number | undefined
  ): Promise<Array<TypedEvent<EventArgsArray & EventArgsObject>>>;

  interface: ComptrollerInterface;

  functions: {
    acceptOwnership(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

    actionPaused(
      market: string,
      action: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    addRewardsDistributor(
      _rewardsDistributor: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

    borrowVerify(
      vToken: string,
      borrower: string,
      borrowAmount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    checkMembership(
      account: string,
      vToken: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

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

    enterMarkets(
      vTokens: string[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    exitMarket(
      vTokenAddress: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    getAccountLiquidity(
      account: string,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber] & {
        error: BigNumber;
        liquidity: BigNumber;
        shortfall: BigNumber;
      }
    >;

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

    getAssetsIn(
      account: string,
      overrides?: CallOverrides
    ): Promise<[string[]]>;

    getBorrowingPower(
      account: string,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber] & {
        error: BigNumber;
        liquidity: BigNumber;
        shortfall: BigNumber;
      }
    >;

    getHypotheticalAccountLiquidity(
      account: string,
      vTokenModify: string,
      redeemTokens: BigNumberish,
      borrowAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber] & {
        error: BigNumber;
        liquidity: BigNumber;
        shortfall: BigNumber;
      }
    >;

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

    getRewardsByMarket(
      vToken: string,
      overrides?: CallOverrides
    ): Promise<
      [
        ([string, BigNumber, BigNumber] & {
          rewardToken: string;
          supplySpeed: BigNumber;
          borrowSpeed: BigNumber;
        })[]
      ] & {
        rewardSpeeds: ([string, BigNumber, BigNumber] & {
          rewardToken: string;
          supplySpeed: BigNumber;
          borrowSpeed: BigNumber;
        })[];
      }
    >;

    healAccount(
      user: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    initialize(
      loopLimit: BigNumberish,
      accessControlManager: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

    isMarketListed(
      vToken: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    liquidateAccount(
      borrower: string,
      orders: {
        vTokenCollateral: string;
        vTokenBorrowed: string;
        repayAmount: BigNumberish;
      }[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    liquidateBorrowVerify(
      vTokenBorrowed: string,
      vTokenCollateral: string,
      liquidator: string,
      borrower: string,
      actualRepayAmount: BigNumberish,
      seizeTokens: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    liquidateCalculateSeizeTokens(
      vTokenBorrowed: string,
      vTokenCollateral: string,
      actualRepayAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & { error: BigNumber; tokensToSeize: BigNumber }
    >;

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

    markets(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<
      [boolean, BigNumber, BigNumber] & {
        isListed: boolean;
        collateralFactorMantissa: BigNumber;
        liquidationThresholdMantissa: BigNumber;
      }
    >;

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

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

    mintVerify(
      vToken: string,
      minter: string,
      actualMintAmount: BigNumberish,
      mintTokens: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

    preBorrowHook(
      vToken: string,
      borrower: string,
      borrowAmount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    preLiquidateHook(
      vTokenBorrowed: string,
      vTokenCollateral: string,
      borrower: string,
      repayAmount: BigNumberish,
      skipLiquidityCheck: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    preMintHook(
      vToken: string,
      minter: string,
      mintAmount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    preRedeemHook(
      vToken: string,
      redeemer: string,
      redeemTokens: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    preRepayHook(
      vToken: string,
      borrower: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    preSeizeHook(
      vTokenCollateral: string,
      seizerContract: string,
      liquidator: string,
      borrower: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    preTransferHook(
      vToken: string,
      src: string,
      dst: string,
      transferTokens: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    redeemVerify(
      vToken: string,
      redeemer: string,
      redeemAmount: BigNumberish,
      redeemTokens: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    repayBorrowVerify(
      vToken: string,
      payer: string,
      borrower: string,
      actualRepayAmount: BigNumberish,
      borrowerIndex: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    seizeVerify(
      vTokenCollateral: string,
      vTokenBorrowed: string,
      liquidator: string,
      borrower: string,
      seizeTokens: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setAccessControlManager(
      accessControlManager_: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setActionsPaused(
      marketsList: string[],
      actionsList: BigNumberish[],
      paused: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setCloseFactor(
      newCloseFactorMantissa: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setCollateralFactor(
      vToken: string,
      newCollateralFactorMantissa: BigNumberish,
      newLiquidationThresholdMantissa: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setForcedLiquidation(
      vTokenBorrowed: string,
      enable: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setLiquidationIncentive(
      newLiquidationIncentiveMantissa: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setMarketBorrowCaps(
      vTokens: string[],
      newBorrowCaps: BigNumberish[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setMarketSupplyCaps(
      vTokens: string[],
      newSupplyCaps: BigNumberish[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setMaxLoopsLimit(
      limit: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setMinLiquidatableCollateral(
      newMinLiquidatableCollateral: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setPriceOracle(
      newOracle: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setPrimeToken(
      _prime: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    supportMarket(
      vToken: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    transferVerify(
      vToken: string,
      src: string,
      dst: string,
      transferTokens: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    unlistMarket(
      market: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    updateDelegate(
      delegate: string,
      approved: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    updatePrices(
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;
  };

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

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

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

  actionPaused(
    market: string,
    action: BigNumberish,
    overrides?: CallOverrides
  ): Promise<boolean>;

  addRewardsDistributor(
    _rewardsDistributor: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

  borrowVerify(
    vToken: string,
    borrower: string,
    borrowAmount: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  checkMembership(
    account: string,
    vToken: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

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

  enterMarkets(
    vTokens: string[],
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  exitMarket(
    vTokenAddress: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  getAccountLiquidity(
    account: string,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber, BigNumber] & {
      error: BigNumber;
      liquidity: BigNumber;
      shortfall: BigNumber;
    }
  >;

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

  getAssetsIn(account: string, overrides?: CallOverrides): Promise<string[]>;

  getBorrowingPower(
    account: string,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber, BigNumber] & {
      error: BigNumber;
      liquidity: BigNumber;
      shortfall: BigNumber;
    }
  >;

  getHypotheticalAccountLiquidity(
    account: string,
    vTokenModify: string,
    redeemTokens: BigNumberish,
    borrowAmount: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber, BigNumber] & {
      error: BigNumber;
      liquidity: BigNumber;
      shortfall: BigNumber;
    }
  >;

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

  getRewardsByMarket(
    vToken: string,
    overrides?: CallOverrides
  ): Promise<
    ([string, BigNumber, BigNumber] & {
      rewardToken: string;
      supplySpeed: BigNumber;
      borrowSpeed: BigNumber;
    })[]
  >;

  healAccount(
    user: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  initialize(
    loopLimit: BigNumberish,
    accessControlManager: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

  isMarketListed(vToken: string, overrides?: CallOverrides): Promise<boolean>;

  liquidateAccount(
    borrower: string,
    orders: {
      vTokenCollateral: string;
      vTokenBorrowed: string;
      repayAmount: BigNumberish;
    }[],
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  liquidateBorrowVerify(
    vTokenBorrowed: string,
    vTokenCollateral: string,
    liquidator: string,
    borrower: string,
    actualRepayAmount: BigNumberish,
    seizeTokens: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  liquidateCalculateSeizeTokens(
    vTokenBorrowed: string,
    vTokenCollateral: string,
    actualRepayAmount: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber] & { error: BigNumber; tokensToSeize: BigNumber }
  >;

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

  markets(
    arg0: string,
    overrides?: CallOverrides
  ): Promise<
    [boolean, BigNumber, BigNumber] & {
      isListed: boolean;
      collateralFactorMantissa: BigNumber;
      liquidationThresholdMantissa: BigNumber;
    }
  >;

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

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

  mintVerify(
    vToken: string,
    minter: string,
    actualMintAmount: BigNumberish,
    mintTokens: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

  preBorrowHook(
    vToken: string,
    borrower: string,
    borrowAmount: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  preLiquidateHook(
    vTokenBorrowed: string,
    vTokenCollateral: string,
    borrower: string,
    repayAmount: BigNumberish,
    skipLiquidityCheck: boolean,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  preMintHook(
    vToken: string,
    minter: string,
    mintAmount: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  preRedeemHook(
    vToken: string,
    redeemer: string,
    redeemTokens: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  preRepayHook(
    vToken: string,
    borrower: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  preSeizeHook(
    vTokenCollateral: string,
    seizerContract: string,
    liquidator: string,
    borrower: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  preTransferHook(
    vToken: string,
    src: string,
    dst: string,
    transferTokens: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  redeemVerify(
    vToken: string,
    redeemer: string,
    redeemAmount: BigNumberish,
    redeemTokens: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  repayBorrowVerify(
    vToken: string,
    payer: string,
    borrower: string,
    actualRepayAmount: BigNumberish,
    borrowerIndex: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  seizeVerify(
    vTokenCollateral: string,
    vTokenBorrowed: string,
    liquidator: string,
    borrower: string,
    seizeTokens: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setAccessControlManager(
    accessControlManager_: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setActionsPaused(
    marketsList: string[],
    actionsList: BigNumberish[],
    paused: boolean,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setCloseFactor(
    newCloseFactorMantissa: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setCollateralFactor(
    vToken: string,
    newCollateralFactorMantissa: BigNumberish,
    newLiquidationThresholdMantissa: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setForcedLiquidation(
    vTokenBorrowed: string,
    enable: boolean,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setLiquidationIncentive(
    newLiquidationIncentiveMantissa: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setMarketBorrowCaps(
    vTokens: string[],
    newBorrowCaps: BigNumberish[],
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setMarketSupplyCaps(
    vTokens: string[],
    newSupplyCaps: BigNumberish[],
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setMaxLoopsLimit(
    limit: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setMinLiquidatableCollateral(
    newMinLiquidatableCollateral: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setPriceOracle(
    newOracle: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setPrimeToken(
    _prime: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  supportMarket(
    vToken: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  transferVerify(
    vToken: string,
    src: string,
    dst: string,
    transferTokens: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  unlistMarket(
    market: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  updateDelegate(
    delegate: string,
    approved: boolean,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  updatePrices(
    account: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  callStatic: {
    acceptOwnership(overrides?: CallOverrides): Promise<void>;

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

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

    actionPaused(
      market: string,
      action: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    addRewardsDistributor(
      _rewardsDistributor: string,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

    borrowVerify(
      vToken: string,
      borrower: string,
      borrowAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    checkMembership(
      account: string,
      vToken: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

    enterMarkets(
      vTokens: string[],
      overrides?: CallOverrides
    ): Promise<BigNumber[]>;

    exitMarket(
      vTokenAddress: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getAccountLiquidity(
      account: string,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber] & {
        error: BigNumber;
        liquidity: BigNumber;
        shortfall: BigNumber;
      }
    >;

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

    getAssetsIn(account: string, overrides?: CallOverrides): Promise<string[]>;

    getBorrowingPower(
      account: string,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber] & {
        error: BigNumber;
        liquidity: BigNumber;
        shortfall: BigNumber;
      }
    >;

    getHypotheticalAccountLiquidity(
      account: string,
      vTokenModify: string,
      redeemTokens: BigNumberish,
      borrowAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber] & {
        error: BigNumber;
        liquidity: BigNumber;
        shortfall: BigNumber;
      }
    >;

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

    getRewardsByMarket(
      vToken: string,
      overrides?: CallOverrides
    ): Promise<
      ([string, BigNumber, BigNumber] & {
        rewardToken: string;
        supplySpeed: BigNumber;
        borrowSpeed: BigNumber;
      })[]
    >;

    healAccount(user: string, overrides?: CallOverrides): Promise<void>;

    initialize(
      loopLimit: BigNumberish,
      accessControlManager: string,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    isMarketListed(vToken: string, overrides?: CallOverrides): Promise<boolean>;

    liquidateAccount(
      borrower: string,
      orders: {
        vTokenCollateral: string;
        vTokenBorrowed: string;
        repayAmount: BigNumberish;
      }[],
      overrides?: CallOverrides
    ): Promise<void>;

    liquidateBorrowVerify(
      vTokenBorrowed: string,
      vTokenCollateral: string,
      liquidator: string,
      borrower: string,
      actualRepayAmount: BigNumberish,
      seizeTokens: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    liquidateCalculateSeizeTokens(
      vTokenBorrowed: string,
      vTokenCollateral: string,
      actualRepayAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & { error: BigNumber; tokensToSeize: BigNumber }
    >;

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

    markets(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<
      [boolean, BigNumber, BigNumber] & {
        isListed: boolean;
        collateralFactorMantissa: BigNumber;
        liquidationThresholdMantissa: BigNumber;
      }
    >;

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

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

    mintVerify(
      vToken: string,
      minter: string,
      actualMintAmount: BigNumberish,
      mintTokens: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

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

    preBorrowHook(
      vToken: string,
      borrower: string,
      borrowAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    preLiquidateHook(
      vTokenBorrowed: string,
      vTokenCollateral: string,
      borrower: string,
      repayAmount: BigNumberish,
      skipLiquidityCheck: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

    preMintHook(
      vToken: string,
      minter: string,
      mintAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    preRedeemHook(
      vToken: string,
      redeemer: string,
      redeemTokens: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    preRepayHook(
      vToken: string,
      borrower: string,
      overrides?: CallOverrides
    ): Promise<void>;

    preSeizeHook(
      vTokenCollateral: string,
      seizerContract: string,
      liquidator: string,
      borrower: string,
      overrides?: CallOverrides
    ): Promise<void>;

    preTransferHook(
      vToken: string,
      src: string,
      dst: string,
      transferTokens: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

    redeemVerify(
      vToken: string,
      redeemer: string,
      redeemAmount: BigNumberish,
      redeemTokens: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

    repayBorrowVerify(
      vToken: string,
      payer: string,
      borrower: string,
      actualRepayAmount: BigNumberish,
      borrowerIndex: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    seizeVerify(
      vTokenCollateral: string,
      vTokenBorrowed: string,
      liquidator: string,
      borrower: string,
      seizeTokens: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setAccessControlManager(
      accessControlManager_: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setActionsPaused(
      marketsList: string[],
      actionsList: BigNumberish[],
      paused: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

    setCloseFactor(
      newCloseFactorMantissa: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setCollateralFactor(
      vToken: string,
      newCollateralFactorMantissa: BigNumberish,
      newLiquidationThresholdMantissa: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setForcedLiquidation(
      vTokenBorrowed: string,
      enable: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

    setLiquidationIncentive(
      newLiquidationIncentiveMantissa: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setMarketBorrowCaps(
      vTokens: string[],
      newBorrowCaps: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<void>;

    setMarketSupplyCaps(
      vTokens: string[],
      newSupplyCaps: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<void>;

    setMaxLoopsLimit(
      limit: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setMinLiquidatableCollateral(
      newMinLiquidatableCollateral: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setPriceOracle(newOracle: string, overrides?: CallOverrides): Promise<void>;

    setPrimeToken(_prime: string, overrides?: CallOverrides): Promise<void>;

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

    supportMarket(vToken: string, overrides?: CallOverrides): Promise<void>;

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

    transferVerify(
      vToken: string,
      src: string,
      dst: string,
      transferTokens: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

    updateDelegate(
      delegate: string,
      approved: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

    updatePrices(account: string, overrides?: CallOverrides): Promise<void>;
  };

  filters: {
    "ActionPausedMarket(address,uint8,bool)"(
      vToken?: null,
      action?: null,
      pauseState?: null
    ): TypedEventFilter<
      [string, number, boolean],
      { vToken: string; action: number; pauseState: boolean }
    >;

    ActionPausedMarket(
      vToken?: null,
      action?: null,
      pauseState?: null
    ): TypedEventFilter<
      [string, number, boolean],
      { vToken: string; action: number; pauseState: boolean }
    >;

    "DelegateUpdated(address,address,bool)"(
      approver?: string | null,
      delegate?: string | null,
      approved?: null
    ): TypedEventFilter<
      [string, string, boolean],
      { approver: string; delegate: string; approved: boolean }
    >;

    DelegateUpdated(
      approver?: string | null,
      delegate?: string | null,
      approved?: null
    ): TypedEventFilter<
      [string, string, boolean],
      { approver: string; delegate: string; approved: boolean }
    >;

    "Initialized(uint8)"(
      version?: null
    ): TypedEventFilter<[number], { version: number }>;

    Initialized(
      version?: null
    ): TypedEventFilter<[number], { version: number }>;

    "IsForcedLiquidationEnabledUpdated(address,bool)"(
      vToken?: string | null,
      enable?: null
    ): TypedEventFilter<[string, boolean], { vToken: string; enable: boolean }>;

    IsForcedLiquidationEnabledUpdated(
      vToken?: string | null,
      enable?: null
    ): TypedEventFilter<[string, boolean], { vToken: string; enable: boolean }>;

    "MarketEntered(address,address)"(
      vToken?: string | null,
      account?: string | null
    ): TypedEventFilter<[string, string], { vToken: string; account: string }>;

    MarketEntered(
      vToken?: string | null,
      account?: string | null
    ): TypedEventFilter<[string, string], { vToken: string; account: string }>;

    "MarketExited(address,address)"(
      vToken?: string | null,
      account?: string | null
    ): TypedEventFilter<[string, string], { vToken: string; account: string }>;

    MarketExited(
      vToken?: string | null,
      account?: string | null
    ): TypedEventFilter<[string, string], { vToken: string; account: string }>;

    "MarketSupported(address)"(
      vToken?: null
    ): TypedEventFilter<[string], { vToken: string }>;

    MarketSupported(
      vToken?: null
    ): TypedEventFilter<[string], { vToken: string }>;

    "MarketUnlisted(address)"(
      vToken?: string | null
    ): TypedEventFilter<[string], { vToken: string }>;

    MarketUnlisted(
      vToken?: string | null
    ): TypedEventFilter<[string], { vToken: string }>;

    "MaxLoopsLimitUpdated(uint256,uint256)"(
      oldMaxLoopsLimit?: null,
      newmaxLoopsLimit?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber],
      { oldMaxLoopsLimit: BigNumber; newmaxLoopsLimit: BigNumber }
    >;

    MaxLoopsLimitUpdated(
      oldMaxLoopsLimit?: null,
      newmaxLoopsLimit?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber],
      { oldMaxLoopsLimit: BigNumber; newmaxLoopsLimit: BigNumber }
    >;

    "NewAccessControlManager(address,address)"(
      oldAccessControlManager?: null,
      newAccessControlManager?: null
    ): TypedEventFilter<
      [string, string],
      { oldAccessControlManager: string; newAccessControlManager: string }
    >;

    NewAccessControlManager(
      oldAccessControlManager?: null,
      newAccessControlManager?: null
    ): TypedEventFilter<
      [string, string],
      { oldAccessControlManager: string; newAccessControlManager: string }
    >;

    "NewBorrowCap(address,uint256)"(
      vToken?: string | null,
      newBorrowCap?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { vToken: string; newBorrowCap: BigNumber }
    >;

    NewBorrowCap(
      vToken?: string | null,
      newBorrowCap?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { vToken: string; newBorrowCap: BigNumber }
    >;

    "NewCloseFactor(uint256,uint256)"(
      oldCloseFactorMantissa?: null,
      newCloseFactorMantissa?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber],
      { oldCloseFactorMantissa: BigNumber; newCloseFactorMantissa: BigNumber }
    >;

    NewCloseFactor(
      oldCloseFactorMantissa?: null,
      newCloseFactorMantissa?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber],
      { oldCloseFactorMantissa: BigNumber; newCloseFactorMantissa: BigNumber }
    >;

    "NewCollateralFactor(address,uint256,uint256)"(
      vToken?: null,
      oldCollateralFactorMantissa?: null,
      newCollateralFactorMantissa?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber],
      {
        vToken: string;
        oldCollateralFactorMantissa: BigNumber;
        newCollateralFactorMantissa: BigNumber;
      }
    >;

    NewCollateralFactor(
      vToken?: null,
      oldCollateralFactorMantissa?: null,
      newCollateralFactorMantissa?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber],
      {
        vToken: string;
        oldCollateralFactorMantissa: BigNumber;
        newCollateralFactorMantissa: BigNumber;
      }
    >;

    "NewLiquidationIncentive(uint256,uint256)"(
      oldLiquidationIncentiveMantissa?: null,
      newLiquidationIncentiveMantissa?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber],
      {
        oldLiquidationIncentiveMantissa: BigNumber;
        newLiquidationIncentiveMantissa: BigNumber;
      }
    >;

    NewLiquidationIncentive(
      oldLiquidationIncentiveMantissa?: null,
      newLiquidationIncentiveMantissa?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber],
      {
        oldLiquidationIncentiveMantissa: BigNumber;
        newLiquidationIncentiveMantissa: BigNumber;
      }
    >;

    "NewLiquidationThreshold(address,uint256,uint256)"(
      vToken?: null,
      oldLiquidationThresholdMantissa?: null,
      newLiquidationThresholdMantissa?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber],
      {
        vToken: string;
        oldLiquidationThresholdMantissa: BigNumber;
        newLiquidationThresholdMantissa: BigNumber;
      }
    >;

    NewLiquidationThreshold(
      vToken?: null,
      oldLiquidationThresholdMantissa?: null,
      newLiquidationThresholdMantissa?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber],
      {
        vToken: string;
        oldLiquidationThresholdMantissa: BigNumber;
        newLiquidationThresholdMantissa: BigNumber;
      }
    >;

    "NewMinLiquidatableCollateral(uint256,uint256)"(
      oldMinLiquidatableCollateral?: null,
      newMinLiquidatableCollateral?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber],
      {
        oldMinLiquidatableCollateral: BigNumber;
        newMinLiquidatableCollateral: BigNumber;
      }
    >;

    NewMinLiquidatableCollateral(
      oldMinLiquidatableCollateral?: null,
      newMinLiquidatableCollateral?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber],
      {
        oldMinLiquidatableCollateral: BigNumber;
        newMinLiquidatableCollateral: BigNumber;
      }
    >;

    "NewPriceOracle(address,address)"(
      oldPriceOracle?: null,
      newPriceOracle?: null
    ): TypedEventFilter<
      [string, string],
      { oldPriceOracle: string; newPriceOracle: string }
    >;

    NewPriceOracle(
      oldPriceOracle?: null,
      newPriceOracle?: null
    ): TypedEventFilter<
      [string, string],
      { oldPriceOracle: string; newPriceOracle: string }
    >;

    "NewPrimeToken(address,address)"(
      oldPrimeToken?: null,
      newPrimeToken?: null
    ): TypedEventFilter<
      [string, string],
      { oldPrimeToken: string; newPrimeToken: string }
    >;

    NewPrimeToken(
      oldPrimeToken?: null,
      newPrimeToken?: null
    ): TypedEventFilter<
      [string, string],
      { oldPrimeToken: string; newPrimeToken: string }
    >;

    "NewRewardsDistributor(address,address)"(
      rewardsDistributor?: string | null,
      rewardToken?: string | null
    ): TypedEventFilter<
      [string, string],
      { rewardsDistributor: string; rewardToken: string }
    >;

    NewRewardsDistributor(
      rewardsDistributor?: string | null,
      rewardToken?: string | null
    ): TypedEventFilter<
      [string, string],
      { rewardsDistributor: string; rewardToken: string }
    >;

    "NewSupplyCap(address,uint256)"(
      vToken?: string | null,
      newSupplyCap?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { vToken: string; newSupplyCap: BigNumber }
    >;

    NewSupplyCap(
      vToken?: string | null,
      newSupplyCap?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { vToken: string; newSupplyCap: BigNumber }
    >;

    "OwnershipTransferStarted(address,address)"(
      previousOwner?: string | null,
      newOwner?: string | null
    ): TypedEventFilter<
      [string, string],
      { previousOwner: string; newOwner: string }
    >;

    OwnershipTransferStarted(
      previousOwner?: string | null,
      newOwner?: string | null
    ): TypedEventFilter<
      [string, string],
      { previousOwner: string; newOwner: string }
    >;

    "OwnershipTransferred(address,address)"(
      previousOwner?: string | null,
      newOwner?: string | null
    ): TypedEventFilter<
      [string, string],
      { previousOwner: string; newOwner: string }
    >;

    OwnershipTransferred(
      previousOwner?: string | null,
      newOwner?: string | null
    ): TypedEventFilter<
      [string, string],
      { previousOwner: string; newOwner: string }
    >;
  };

  estimateGas: {
    acceptOwnership(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

    actionPaused(
      market: string,
      action: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    addRewardsDistributor(
      _rewardsDistributor: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

    borrowVerify(
      vToken: string,
      borrower: string,
      borrowAmount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    checkMembership(
      account: string,
      vToken: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    enterMarkets(
      vTokens: string[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    exitMarket(
      vTokenAddress: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    getAccountLiquidity(
      account: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    getAssetsIn(account: string, overrides?: CallOverrides): Promise<BigNumber>;

    getBorrowingPower(
      account: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getHypotheticalAccountLiquidity(
      account: string,
      vTokenModify: string,
      redeemTokens: BigNumberish,
      borrowAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    getRewardsByMarket(
      vToken: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    healAccount(
      user: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    initialize(
      loopLimit: BigNumberish,
      accessControlManager: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

    isMarketListed(
      vToken: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    liquidateAccount(
      borrower: string,
      orders: {
        vTokenCollateral: string;
        vTokenBorrowed: string;
        repayAmount: BigNumberish;
      }[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    liquidateBorrowVerify(
      vTokenBorrowed: string,
      vTokenCollateral: string,
      liquidator: string,
      borrower: string,
      actualRepayAmount: BigNumberish,
      seizeTokens: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    liquidateCalculateSeizeTokens(
      vTokenBorrowed: string,
      vTokenCollateral: string,
      actualRepayAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

    mintVerify(
      vToken: string,
      minter: string,
      actualMintAmount: BigNumberish,
      mintTokens: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

    preBorrowHook(
      vToken: string,
      borrower: string,
      borrowAmount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    preLiquidateHook(
      vTokenBorrowed: string,
      vTokenCollateral: string,
      borrower: string,
      repayAmount: BigNumberish,
      skipLiquidityCheck: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    preMintHook(
      vToken: string,
      minter: string,
      mintAmount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    preRedeemHook(
      vToken: string,
      redeemer: string,
      redeemTokens: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    preRepayHook(
      vToken: string,
      borrower: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    preSeizeHook(
      vTokenCollateral: string,
      seizerContract: string,
      liquidator: string,
      borrower: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    preTransferHook(
      vToken: string,
      src: string,
      dst: string,
      transferTokens: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    redeemVerify(
      vToken: string,
      redeemer: string,
      redeemAmount: BigNumberish,
      redeemTokens: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    repayBorrowVerify(
      vToken: string,
      payer: string,
      borrower: string,
      actualRepayAmount: BigNumberish,
      borrowerIndex: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    seizeVerify(
      vTokenCollateral: string,
      vTokenBorrowed: string,
      liquidator: string,
      borrower: string,
      seizeTokens: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setAccessControlManager(
      accessControlManager_: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setActionsPaused(
      marketsList: string[],
      actionsList: BigNumberish[],
      paused: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setCloseFactor(
      newCloseFactorMantissa: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setCollateralFactor(
      vToken: string,
      newCollateralFactorMantissa: BigNumberish,
      newLiquidationThresholdMantissa: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setForcedLiquidation(
      vTokenBorrowed: string,
      enable: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setLiquidationIncentive(
      newLiquidationIncentiveMantissa: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setMarketBorrowCaps(
      vTokens: string[],
      newBorrowCaps: BigNumberish[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setMarketSupplyCaps(
      vTokens: string[],
      newSupplyCaps: BigNumberish[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setMaxLoopsLimit(
      limit: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setMinLiquidatableCollateral(
      newMinLiquidatableCollateral: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setPriceOracle(
      newOracle: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setPrimeToken(
      _prime: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    supportMarket(
      vToken: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    transferVerify(
      vToken: string,
      src: string,
      dst: string,
      transferTokens: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    unlistMarket(
      market: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    updateDelegate(
      delegate: string,
      approved: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    updatePrices(
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;
  };

  populateTransaction: {
    acceptOwnership(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

    actionPaused(
      market: string,
      action: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    addRewardsDistributor(
      _rewardsDistributor: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

    borrowVerify(
      vToken: string,
      borrower: string,
      borrowAmount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    checkMembership(
      account: string,
      vToken: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    enterMarkets(
      vTokens: string[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    exitMarket(
      vTokenAddress: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    getAccountLiquidity(
      account: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    getAssetsIn(
      account: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getBorrowingPower(
      account: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getHypotheticalAccountLiquidity(
      account: string,
      vTokenModify: string,
      redeemTokens: BigNumberish,
      borrowAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    getRewardsByMarket(
      vToken: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    healAccount(
      user: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    initialize(
      loopLimit: BigNumberish,
      accessControlManager: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

    isMarketListed(
      vToken: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    liquidateAccount(
      borrower: string,
      orders: {
        vTokenCollateral: string;
        vTokenBorrowed: string;
        repayAmount: BigNumberish;
      }[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    liquidateBorrowVerify(
      vTokenBorrowed: string,
      vTokenCollateral: string,
      liquidator: string,
      borrower: string,
      actualRepayAmount: BigNumberish,
      seizeTokens: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    liquidateCalculateSeizeTokens(
      vTokenBorrowed: string,
      vTokenCollateral: string,
      actualRepayAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

    mintVerify(
      vToken: string,
      minter: string,
      actualMintAmount: BigNumberish,
      mintTokens: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

    preBorrowHook(
      vToken: string,
      borrower: string,
      borrowAmount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    preLiquidateHook(
      vTokenBorrowed: string,
      vTokenCollateral: string,
      borrower: string,
      repayAmount: BigNumberish,
      skipLiquidityCheck: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    preMintHook(
      vToken: string,
      minter: string,
      mintAmount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    preRedeemHook(
      vToken: string,
      redeemer: string,
      redeemTokens: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    preRepayHook(
      vToken: string,
      borrower: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    preSeizeHook(
      vTokenCollateral: string,
      seizerContract: string,
      liquidator: string,
      borrower: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    preTransferHook(
      vToken: string,
      src: string,
      dst: string,
      transferTokens: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    redeemVerify(
      vToken: string,
      redeemer: string,
      redeemAmount: BigNumberish,
      redeemTokens: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    repayBorrowVerify(
      vToken: string,
      payer: string,
      borrower: string,
      actualRepayAmount: BigNumberish,
      borrowerIndex: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    seizeVerify(
      vTokenCollateral: string,
      vTokenBorrowed: string,
      liquidator: string,
      borrower: string,
      seizeTokens: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setAccessControlManager(
      accessControlManager_: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setActionsPaused(
      marketsList: string[],
      actionsList: BigNumberish[],
      paused: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setCloseFactor(
      newCloseFactorMantissa: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setCollateralFactor(
      vToken: string,
      newCollateralFactorMantissa: BigNumberish,
      newLiquidationThresholdMantissa: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setForcedLiquidation(
      vTokenBorrowed: string,
      enable: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setLiquidationIncentive(
      newLiquidationIncentiveMantissa: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setMarketBorrowCaps(
      vTokens: string[],
      newBorrowCaps: BigNumberish[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setMarketSupplyCaps(
      vTokens: string[],
      newSupplyCaps: BigNumberish[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setMaxLoopsLimit(
      limit: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setMinLiquidatableCollateral(
      newMinLiquidatableCollateral: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setPriceOracle(
      newOracle: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setPrimeToken(
      _prime: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    supportMarket(
      vToken: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    transferVerify(
      vToken: string,
      src: string,
      dst: string,
      transferTokens: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    unlistMarket(
      market: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    updateDelegate(
      delegate: string,
      approved: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    updatePrices(
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;
  };
}