/* 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 VTokenInterfaceInterface extends ethers.utils.Interface {
  functions: {
    "accrualBlockNumber()": FunctionFragment;
    "accrueInterest()": FunctionFragment;
    "addReserves(uint256)": FunctionFragment;
    "allowance(address,address)": FunctionFragment;
    "approve(address,uint256)": FunctionFragment;
    "badDebt()": FunctionFragment;
    "balanceOf(address)": FunctionFragment;
    "balanceOfUnderlying(address)": FunctionFragment;
    "borrow(uint256)": FunctionFragment;
    "borrowBalanceCurrent(address)": FunctionFragment;
    "borrowBalanceStored(address)": FunctionFragment;
    "borrowBehalf(address,uint256)": FunctionFragment;
    "borrowIndex()": FunctionFragment;
    "borrowRatePerBlock()": FunctionFragment;
    "comptroller()": FunctionFragment;
    "decimals()": FunctionFragment;
    "decreaseAllowance(address,uint256)": FunctionFragment;
    "exchangeRateCurrent()": FunctionFragment;
    "exchangeRateStored()": FunctionFragment;
    "forceLiquidateBorrow(address,address,uint256,address,bool)": FunctionFragment;
    "getAccountSnapshot(address)": FunctionFragment;
    "getCash()": FunctionFragment;
    "healBorrow(address,address,uint256)": FunctionFragment;
    "increaseAllowance(address,uint256)": FunctionFragment;
    "interestRateModel()": FunctionFragment;
    "isVToken()": FunctionFragment;
    "liquidateBorrow(address,uint256,address)": FunctionFragment;
    "mint(uint256)": FunctionFragment;
    "mintBehalf(address,uint256)": FunctionFragment;
    "name()": FunctionFragment;
    "protocolSeizeShareMantissa()": FunctionFragment;
    "protocolShareReserve()": FunctionFragment;
    "redeem(uint256)": FunctionFragment;
    "redeemBehalf(address,uint256)": FunctionFragment;
    "redeemUnderlying(uint256)": FunctionFragment;
    "redeemUnderlyingBehalf(address,uint256)": FunctionFragment;
    "reduceReserves(uint256)": FunctionFragment;
    "reduceReservesBlockDelta()": FunctionFragment;
    "reduceReservesBlockNumber()": FunctionFragment;
    "repayBorrow(uint256)": FunctionFragment;
    "repayBorrowBehalf(address,uint256)": FunctionFragment;
    "reserveFactorMantissa()": FunctionFragment;
    "seize(address,address,uint256)": FunctionFragment;
    "setInterestRateModel(address)": FunctionFragment;
    "setReserveFactor(uint256)": FunctionFragment;
    "shortfall()": FunctionFragment;
    "supplyRatePerBlock()": FunctionFragment;
    "sweepToken(address)": FunctionFragment;
    "symbol()": FunctionFragment;
    "totalBorrows()": FunctionFragment;
    "totalBorrowsCurrent()": FunctionFragment;
    "totalReserves()": FunctionFragment;
    "totalSupply()": FunctionFragment;
    "transfer(address,uint256)": FunctionFragment;
    "transferFrom(address,address,uint256)": FunctionFragment;
    "underlying()": FunctionFragment;
  };

  encodeFunctionData(
    functionFragment: "accrualBlockNumber",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "accrueInterest",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "addReserves",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "allowance",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "approve",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "badDebt", values?: undefined): string;
  encodeFunctionData(functionFragment: "balanceOf", values: [string]): string;
  encodeFunctionData(
    functionFragment: "balanceOfUnderlying",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "borrow",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "borrowBalanceCurrent",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "borrowBalanceStored",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "borrowBehalf",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "borrowIndex",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "borrowRatePerBlock",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "comptroller",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "decimals", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "decreaseAllowance",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "exchangeRateCurrent",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "exchangeRateStored",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "forceLiquidateBorrow",
    values: [string, string, BigNumberish, string, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "getAccountSnapshot",
    values: [string]
  ): string;
  encodeFunctionData(functionFragment: "getCash", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "healBorrow",
    values: [string, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "increaseAllowance",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "interestRateModel",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "isVToken", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "liquidateBorrow",
    values: [string, BigNumberish, string]
  ): string;
  encodeFunctionData(functionFragment: "mint", values: [BigNumberish]): string;
  encodeFunctionData(
    functionFragment: "mintBehalf",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "name", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "protocolSeizeShareMantissa",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "protocolShareReserve",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "redeem",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "redeemBehalf",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "redeemUnderlying",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "redeemUnderlyingBehalf",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "reduceReserves",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "reduceReservesBlockDelta",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "reduceReservesBlockNumber",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "repayBorrow",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "repayBorrowBehalf",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "reserveFactorMantissa",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "seize",
    values: [string, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setInterestRateModel",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setReserveFactor",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "shortfall", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "supplyRatePerBlock",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "sweepToken", values: [string]): string;
  encodeFunctionData(functionFragment: "symbol", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "totalBorrows",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "totalBorrowsCurrent",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "totalReserves",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "totalSupply",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "transfer",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "transferFrom",
    values: [string, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "underlying",
    values?: undefined
  ): string;

  decodeFunctionResult(
    functionFragment: "accrualBlockNumber",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "accrueInterest",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "addReserves",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "badDebt", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "balanceOfUnderlying",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "borrow", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "borrowBalanceCurrent",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "borrowBalanceStored",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "borrowBehalf",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "borrowIndex",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "borrowRatePerBlock",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "comptroller",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "decreaseAllowance",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "exchangeRateCurrent",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "exchangeRateStored",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "forceLiquidateBorrow",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getAccountSnapshot",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "getCash", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "healBorrow", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "increaseAllowance",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "interestRateModel",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "isVToken", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "liquidateBorrow",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "mint", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "mintBehalf", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "protocolSeizeShareMantissa",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "protocolShareReserve",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "redeem", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "redeemBehalf",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "redeemUnderlying",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "redeemUnderlyingBehalf",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "reduceReserves",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "reduceReservesBlockDelta",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "reduceReservesBlockNumber",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "repayBorrow",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "repayBorrowBehalf",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "reserveFactorMantissa",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "seize", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setInterestRateModel",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setReserveFactor",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "shortfall", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "supplyRatePerBlock",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "sweepToken", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "totalBorrows",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "totalBorrowsCurrent",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "totalReserves",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "totalSupply",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "transferFrom",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "underlying", data: BytesLike): Result;

  events: {
    "AccrueInterest(uint256,uint256,uint256,uint256)": EventFragment;
    "Approval(address,address,uint256)": EventFragment;
    "BadDebtIncreased(address,uint256,uint256,uint256)": EventFragment;
    "BadDebtRecovered(uint256,uint256)": EventFragment;
    "Borrow(address,uint256,uint256,uint256)": EventFragment;
    "HealBorrow(address,address,uint256)": EventFragment;
    "LiquidateBorrow(address,address,uint256,address,uint256)": EventFragment;
    "Mint(address,uint256,uint256,uint256)": EventFragment;
    "NewComptroller(address,address)": EventFragment;
    "NewMarketInterestRateModel(address,address)": EventFragment;
    "NewProtocolSeizeShare(uint256,uint256)": EventFragment;
    "NewProtocolShareReserve(address,address)": EventFragment;
    "NewReduceReservesBlockDelta(uint256,uint256)": EventFragment;
    "NewReserveFactor(uint256,uint256)": EventFragment;
    "NewShortfallContract(address,address)": EventFragment;
    "ProtocolSeize(address,address,uint256)": EventFragment;
    "Redeem(address,uint256,uint256,uint256)": EventFragment;
    "RepayBorrow(address,address,uint256,uint256,uint256)": EventFragment;
    "ReservesAdded(address,uint256,uint256)": EventFragment;
    "SpreadReservesReduced(address,uint256,uint256)": EventFragment;
    "SweepToken(address)": EventFragment;
    "Transfer(address,address,uint256)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "AccrueInterest"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "BadDebtIncreased"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "BadDebtRecovered"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Borrow"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "HealBorrow"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LiquidateBorrow"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Mint"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewComptroller"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewMarketInterestRateModel"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewProtocolSeizeShare"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewProtocolShareReserve"): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "NewReduceReservesBlockDelta"
  ): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewReserveFactor"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewShortfallContract"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ProtocolSeize"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Redeem"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RepayBorrow"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ReservesAdded"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SpreadReservesReduced"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SweepToken"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment;
}

export type AccrueInterestEvent = TypedEvent<
  [BigNumber, BigNumber, BigNumber, BigNumber] & {
    cashPrior: BigNumber;
    interestAccumulated: BigNumber;
    borrowIndex: BigNumber;
    totalBorrows: BigNumber;
  }
>;

export type ApprovalEvent = TypedEvent<
  [string, string, BigNumber] & {
    owner: string;
    spender: string;
    amount: BigNumber;
  }
>;

export type BadDebtIncreasedEvent = TypedEvent<
  [string, BigNumber, BigNumber, BigNumber] & {
    borrower: string;
    badDebtDelta: BigNumber;
    badDebtOld: BigNumber;
    badDebtNew: BigNumber;
  }
>;

export type BadDebtRecoveredEvent = TypedEvent<
  [BigNumber, BigNumber] & { badDebtOld: BigNumber; badDebtNew: BigNumber }
>;

export type BorrowEvent = TypedEvent<
  [string, BigNumber, BigNumber, BigNumber] & {
    borrower: string;
    borrowAmount: BigNumber;
    accountBorrows: BigNumber;
    totalBorrows: BigNumber;
  }
>;

export type HealBorrowEvent = TypedEvent<
  [string, string, BigNumber] & {
    payer: string;
    borrower: string;
    repayAmount: BigNumber;
  }
>;

export type LiquidateBorrowEvent = TypedEvent<
  [string, string, BigNumber, string, BigNumber] & {
    liquidator: string;
    borrower: string;
    repayAmount: BigNumber;
    vTokenCollateral: string;
    seizeTokens: BigNumber;
  }
>;

export type MintEvent = TypedEvent<
  [string, BigNumber, BigNumber, BigNumber] & {
    minter: string;
    mintAmount: BigNumber;
    mintTokens: BigNumber;
    accountBalance: BigNumber;
  }
>;

export type NewComptrollerEvent = TypedEvent<
  [string, string] & { oldComptroller: string; newComptroller: string }
>;

export type NewMarketInterestRateModelEvent = TypedEvent<
  [string, string] & {
    oldInterestRateModel: string;
    newInterestRateModel: string;
  }
>;

export type NewProtocolSeizeShareEvent = TypedEvent<
  [BigNumber, BigNumber] & {
    oldProtocolSeizeShareMantissa: BigNumber;
    newProtocolSeizeShareMantissa: BigNumber;
  }
>;

export type NewProtocolShareReserveEvent = TypedEvent<
  [string, string] & {
    oldProtocolShareReserve: string;
    newProtocolShareReserve: string;
  }
>;

export type NewReduceReservesBlockDeltaEvent = TypedEvent<
  [BigNumber, BigNumber] & {
    oldReduceReservesBlockOrTimestampDelta: BigNumber;
    newReduceReservesBlockOrTimestampDelta: BigNumber;
  }
>;

export type NewReserveFactorEvent = TypedEvent<
  [BigNumber, BigNumber] & {
    oldReserveFactorMantissa: BigNumber;
    newReserveFactorMantissa: BigNumber;
  }
>;

export type NewShortfallContractEvent = TypedEvent<
  [string, string] & { oldShortfall: string; newShortfall: string }
>;

export type ProtocolSeizeEvent = TypedEvent<
  [string, string, BigNumber] & { from: string; to: string; amount: BigNumber }
>;

export type RedeemEvent = TypedEvent<
  [string, BigNumber, BigNumber, BigNumber] & {
    redeemer: string;
    redeemAmount: BigNumber;
    redeemTokens: BigNumber;
    accountBalance: BigNumber;
  }
>;

export type RepayBorrowEvent = TypedEvent<
  [string, string, BigNumber, BigNumber, BigNumber] & {
    payer: string;
    borrower: string;
    repayAmount: BigNumber;
    accountBorrows: BigNumber;
    totalBorrows: BigNumber;
  }
>;

export type ReservesAddedEvent = TypedEvent<
  [string, BigNumber, BigNumber] & {
    benefactor: string;
    addAmount: BigNumber;
    newTotalReserves: BigNumber;
  }
>;

export type SpreadReservesReducedEvent = TypedEvent<
  [string, BigNumber, BigNumber] & {
    protocolShareReserve: string;
    reduceAmount: BigNumber;
    newTotalReserves: BigNumber;
  }
>;

export type SweepTokenEvent = TypedEvent<[string] & { token: string }>;

export type TransferEvent = TypedEvent<
  [string, string, BigNumber] & { from: string; to: string; amount: BigNumber }
>;

export class VTokenInterface 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: VTokenInterfaceInterface;

  functions: {
    accrualBlockNumber(overrides?: CallOverrides): Promise<[BigNumber]>;

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

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

    allowance(
      owner: string,
      spender: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    approve(
      spender: string,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

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

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

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

    decreaseAllowance(
      spender: string,
      subtractedValue: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

    forceLiquidateBorrow(
      liquidator: string,
      borrower: string,
      repayAmount: BigNumberish,
      vTokenCollateral: string,
      skipCloseFactorCheck: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

    healBorrow(
      payer: string,
      borrower: string,
      repayAmount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    increaseAllowance(
      spender: string,
      addedValue: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    transfer(
      dst: string,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

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

  allowance(
    owner: string,
    spender: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  approve(
    spender: string,
    amount: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

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

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

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

  decreaseAllowance(
    spender: string,
    subtractedValue: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

  forceLiquidateBorrow(
    liquidator: string,
    borrower: string,
    repayAmount: BigNumberish,
    vTokenCollateral: string,
    skipCloseFactorCheck: boolean,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

  healBorrow(
    payer: string,
    borrower: string,
    repayAmount: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  increaseAllowance(
    spender: string,
    addedValue: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  transfer(
    dst: string,
    amount: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

  callStatic: {
    accrualBlockNumber(overrides?: CallOverrides): Promise<BigNumber>;

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

    addReserves(
      addAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    allowance(
      owner: string,
      spender: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    approve(
      spender: string,
      amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

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

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

    borrow(
      borrowAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    borrowBehalf(
      borrwwer: string,
      borrowAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

    decreaseAllowance(
      spender: string,
      subtractedValue: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

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

    forceLiquidateBorrow(
      liquidator: string,
      borrower: string,
      repayAmount: BigNumberish,
      vTokenCollateral: string,
      skipCloseFactorCheck: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    healBorrow(
      payer: string,
      borrower: string,
      repayAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    increaseAllowance(
      spender: string,
      addedValue: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

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

    liquidateBorrow(
      borrower: string,
      repayAmount: BigNumberish,
      vTokenCollateral: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    mint(
      mintAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    mintBehalf(
      minter: string,
      mintAllowed: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

    redeem(
      redeemTokens: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    redeemBehalf(
      redeemer: string,
      redeemTokens: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    redeemUnderlying(
      redeemAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    redeemUnderlyingBehalf(
      redeemer: string,
      redeemAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    reduceReserves(
      reduceAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    repayBorrow(
      repayAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    repayBorrowBehalf(
      borrower: string,
      repayAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    setInterestRateModel(
      newInterestRateModel: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setReserveFactor(
      newReserveFactorMantissa: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    sweepToken(token: string, overrides?: CallOverrides): Promise<void>;

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

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

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

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

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

    transfer(
      dst: string,
      amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    transferFrom(
      src: string,
      dst: string,
      amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    underlying(overrides?: CallOverrides): Promise<string>;
  };

  filters: {
    "AccrueInterest(uint256,uint256,uint256,uint256)"(
      cashPrior?: null,
      interestAccumulated?: null,
      borrowIndex?: null,
      totalBorrows?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber, BigNumber, BigNumber],
      {
        cashPrior: BigNumber;
        interestAccumulated: BigNumber;
        borrowIndex: BigNumber;
        totalBorrows: BigNumber;
      }
    >;

    AccrueInterest(
      cashPrior?: null,
      interestAccumulated?: null,
      borrowIndex?: null,
      totalBorrows?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber, BigNumber, BigNumber],
      {
        cashPrior: BigNumber;
        interestAccumulated: BigNumber;
        borrowIndex: BigNumber;
        totalBorrows: BigNumber;
      }
    >;

    "Approval(address,address,uint256)"(
      owner?: string | null,
      spender?: string | null,
      amount?: null
    ): TypedEventFilter<
      [string, string, BigNumber],
      { owner: string; spender: string; amount: BigNumber }
    >;

    Approval(
      owner?: string | null,
      spender?: string | null,
      amount?: null
    ): TypedEventFilter<
      [string, string, BigNumber],
      { owner: string; spender: string; amount: BigNumber }
    >;

    "BadDebtIncreased(address,uint256,uint256,uint256)"(
      borrower?: string | null,
      badDebtDelta?: null,
      badDebtOld?: null,
      badDebtNew?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber, BigNumber],
      {
        borrower: string;
        badDebtDelta: BigNumber;
        badDebtOld: BigNumber;
        badDebtNew: BigNumber;
      }
    >;

    BadDebtIncreased(
      borrower?: string | null,
      badDebtDelta?: null,
      badDebtOld?: null,
      badDebtNew?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber, BigNumber],
      {
        borrower: string;
        badDebtDelta: BigNumber;
        badDebtOld: BigNumber;
        badDebtNew: BigNumber;
      }
    >;

    "BadDebtRecovered(uint256,uint256)"(
      badDebtOld?: null,
      badDebtNew?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber],
      { badDebtOld: BigNumber; badDebtNew: BigNumber }
    >;

    BadDebtRecovered(
      badDebtOld?: null,
      badDebtNew?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber],
      { badDebtOld: BigNumber; badDebtNew: BigNumber }
    >;

    "Borrow(address,uint256,uint256,uint256)"(
      borrower?: string | null,
      borrowAmount?: null,
      accountBorrows?: null,
      totalBorrows?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber, BigNumber],
      {
        borrower: string;
        borrowAmount: BigNumber;
        accountBorrows: BigNumber;
        totalBorrows: BigNumber;
      }
    >;

    Borrow(
      borrower?: string | null,
      borrowAmount?: null,
      accountBorrows?: null,
      totalBorrows?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber, BigNumber],
      {
        borrower: string;
        borrowAmount: BigNumber;
        accountBorrows: BigNumber;
        totalBorrows: BigNumber;
      }
    >;

    "HealBorrow(address,address,uint256)"(
      payer?: string | null,
      borrower?: string | null,
      repayAmount?: null
    ): TypedEventFilter<
      [string, string, BigNumber],
      { payer: string; borrower: string; repayAmount: BigNumber }
    >;

    HealBorrow(
      payer?: string | null,
      borrower?: string | null,
      repayAmount?: null
    ): TypedEventFilter<
      [string, string, BigNumber],
      { payer: string; borrower: string; repayAmount: BigNumber }
    >;

    "LiquidateBorrow(address,address,uint256,address,uint256)"(
      liquidator?: string | null,
      borrower?: string | null,
      repayAmount?: null,
      vTokenCollateral?: string | null,
      seizeTokens?: null
    ): TypedEventFilter<
      [string, string, BigNumber, string, BigNumber],
      {
        liquidator: string;
        borrower: string;
        repayAmount: BigNumber;
        vTokenCollateral: string;
        seizeTokens: BigNumber;
      }
    >;

    LiquidateBorrow(
      liquidator?: string | null,
      borrower?: string | null,
      repayAmount?: null,
      vTokenCollateral?: string | null,
      seizeTokens?: null
    ): TypedEventFilter<
      [string, string, BigNumber, string, BigNumber],
      {
        liquidator: string;
        borrower: string;
        repayAmount: BigNumber;
        vTokenCollateral: string;
        seizeTokens: BigNumber;
      }
    >;

    "Mint(address,uint256,uint256,uint256)"(
      minter?: string | null,
      mintAmount?: null,
      mintTokens?: null,
      accountBalance?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber, BigNumber],
      {
        minter: string;
        mintAmount: BigNumber;
        mintTokens: BigNumber;
        accountBalance: BigNumber;
      }
    >;

    Mint(
      minter?: string | null,
      mintAmount?: null,
      mintTokens?: null,
      accountBalance?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber, BigNumber],
      {
        minter: string;
        mintAmount: BigNumber;
        mintTokens: BigNumber;
        accountBalance: BigNumber;
      }
    >;

    "NewComptroller(address,address)"(
      oldComptroller?: string | null,
      newComptroller?: string | null
    ): TypedEventFilter<
      [string, string],
      { oldComptroller: string; newComptroller: string }
    >;

    NewComptroller(
      oldComptroller?: string | null,
      newComptroller?: string | null
    ): TypedEventFilter<
      [string, string],
      { oldComptroller: string; newComptroller: string }
    >;

    "NewMarketInterestRateModel(address,address)"(
      oldInterestRateModel?: string | null,
      newInterestRateModel?: string | null
    ): TypedEventFilter<
      [string, string],
      { oldInterestRateModel: string; newInterestRateModel: string }
    >;

    NewMarketInterestRateModel(
      oldInterestRateModel?: string | null,
      newInterestRateModel?: string | null
    ): TypedEventFilter<
      [string, string],
      { oldInterestRateModel: string; newInterestRateModel: string }
    >;

    "NewProtocolSeizeShare(uint256,uint256)"(
      oldProtocolSeizeShareMantissa?: null,
      newProtocolSeizeShareMantissa?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber],
      {
        oldProtocolSeizeShareMantissa: BigNumber;
        newProtocolSeizeShareMantissa: BigNumber;
      }
    >;

    NewProtocolSeizeShare(
      oldProtocolSeizeShareMantissa?: null,
      newProtocolSeizeShareMantissa?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber],
      {
        oldProtocolSeizeShareMantissa: BigNumber;
        newProtocolSeizeShareMantissa: BigNumber;
      }
    >;

    "NewProtocolShareReserve(address,address)"(
      oldProtocolShareReserve?: string | null,
      newProtocolShareReserve?: string | null
    ): TypedEventFilter<
      [string, string],
      { oldProtocolShareReserve: string; newProtocolShareReserve: string }
    >;

    NewProtocolShareReserve(
      oldProtocolShareReserve?: string | null,
      newProtocolShareReserve?: string | null
    ): TypedEventFilter<
      [string, string],
      { oldProtocolShareReserve: string; newProtocolShareReserve: string }
    >;

    "NewReduceReservesBlockDelta(uint256,uint256)"(
      oldReduceReservesBlockOrTimestampDelta?: null,
      newReduceReservesBlockOrTimestampDelta?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber],
      {
        oldReduceReservesBlockOrTimestampDelta: BigNumber;
        newReduceReservesBlockOrTimestampDelta: BigNumber;
      }
    >;

    NewReduceReservesBlockDelta(
      oldReduceReservesBlockOrTimestampDelta?: null,
      newReduceReservesBlockOrTimestampDelta?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber],
      {
        oldReduceReservesBlockOrTimestampDelta: BigNumber;
        newReduceReservesBlockOrTimestampDelta: BigNumber;
      }
    >;

    "NewReserveFactor(uint256,uint256)"(
      oldReserveFactorMantissa?: null,
      newReserveFactorMantissa?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber],
      {
        oldReserveFactorMantissa: BigNumber;
        newReserveFactorMantissa: BigNumber;
      }
    >;

    NewReserveFactor(
      oldReserveFactorMantissa?: null,
      newReserveFactorMantissa?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber],
      {
        oldReserveFactorMantissa: BigNumber;
        newReserveFactorMantissa: BigNumber;
      }
    >;

    "NewShortfallContract(address,address)"(
      oldShortfall?: string | null,
      newShortfall?: string | null
    ): TypedEventFilter<
      [string, string],
      { oldShortfall: string; newShortfall: string }
    >;

    NewShortfallContract(
      oldShortfall?: string | null,
      newShortfall?: string | null
    ): TypedEventFilter<
      [string, string],
      { oldShortfall: string; newShortfall: string }
    >;

    "ProtocolSeize(address,address,uint256)"(
      from?: string | null,
      to?: string | null,
      amount?: null
    ): TypedEventFilter<
      [string, string, BigNumber],
      { from: string; to: string; amount: BigNumber }
    >;

    ProtocolSeize(
      from?: string | null,
      to?: string | null,
      amount?: null
    ): TypedEventFilter<
      [string, string, BigNumber],
      { from: string; to: string; amount: BigNumber }
    >;

    "Redeem(address,uint256,uint256,uint256)"(
      redeemer?: string | null,
      redeemAmount?: null,
      redeemTokens?: null,
      accountBalance?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber, BigNumber],
      {
        redeemer: string;
        redeemAmount: BigNumber;
        redeemTokens: BigNumber;
        accountBalance: BigNumber;
      }
    >;

    Redeem(
      redeemer?: string | null,
      redeemAmount?: null,
      redeemTokens?: null,
      accountBalance?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber, BigNumber],
      {
        redeemer: string;
        redeemAmount: BigNumber;
        redeemTokens: BigNumber;
        accountBalance: BigNumber;
      }
    >;

    "RepayBorrow(address,address,uint256,uint256,uint256)"(
      payer?: string | null,
      borrower?: string | null,
      repayAmount?: null,
      accountBorrows?: null,
      totalBorrows?: null
    ): TypedEventFilter<
      [string, string, BigNumber, BigNumber, BigNumber],
      {
        payer: string;
        borrower: string;
        repayAmount: BigNumber;
        accountBorrows: BigNumber;
        totalBorrows: BigNumber;
      }
    >;

    RepayBorrow(
      payer?: string | null,
      borrower?: string | null,
      repayAmount?: null,
      accountBorrows?: null,
      totalBorrows?: null
    ): TypedEventFilter<
      [string, string, BigNumber, BigNumber, BigNumber],
      {
        payer: string;
        borrower: string;
        repayAmount: BigNumber;
        accountBorrows: BigNumber;
        totalBorrows: BigNumber;
      }
    >;

    "ReservesAdded(address,uint256,uint256)"(
      benefactor?: string | null,
      addAmount?: null,
      newTotalReserves?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber],
      { benefactor: string; addAmount: BigNumber; newTotalReserves: BigNumber }
    >;

    ReservesAdded(
      benefactor?: string | null,
      addAmount?: null,
      newTotalReserves?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber],
      { benefactor: string; addAmount: BigNumber; newTotalReserves: BigNumber }
    >;

    "SpreadReservesReduced(address,uint256,uint256)"(
      protocolShareReserve?: string | null,
      reduceAmount?: null,
      newTotalReserves?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber],
      {
        protocolShareReserve: string;
        reduceAmount: BigNumber;
        newTotalReserves: BigNumber;
      }
    >;

    SpreadReservesReduced(
      protocolShareReserve?: string | null,
      reduceAmount?: null,
      newTotalReserves?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber],
      {
        protocolShareReserve: string;
        reduceAmount: BigNumber;
        newTotalReserves: BigNumber;
      }
    >;

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

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

    "Transfer(address,address,uint256)"(
      from?: string | null,
      to?: string | null,
      amount?: null
    ): TypedEventFilter<
      [string, string, BigNumber],
      { from: string; to: string; amount: BigNumber }
    >;

    Transfer(
      from?: string | null,
      to?: string | null,
      amount?: null
    ): TypedEventFilter<
      [string, string, BigNumber],
      { from: string; to: string; amount: BigNumber }
    >;
  };

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

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

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

    allowance(
      owner: string,
      spender: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    approve(
      spender: string,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

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

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

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

    decreaseAllowance(
      spender: string,
      subtractedValue: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

    forceLiquidateBorrow(
      liquidator: string,
      borrower: string,
      repayAmount: BigNumberish,
      vTokenCollateral: string,
      skipCloseFactorCheck: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

    healBorrow(
      payer: string,
      borrower: string,
      repayAmount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    increaseAllowance(
      spender: string,
      addedValue: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    transfer(
      dst: string,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    underlying(overrides?: CallOverrides): Promise<BigNumber>;
  };

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

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

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

    allowance(
      owner: string,
      spender: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    approve(
      spender: string,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

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

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

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

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

    decreaseAllowance(
      spender: string,
      subtractedValue: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

    forceLiquidateBorrow(
      liquidator: string,
      borrower: string,
      repayAmount: BigNumberish,
      vTokenCollateral: string,
      skipCloseFactorCheck: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

    healBorrow(
      payer: string,
      borrower: string,
      repayAmount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    increaseAllowance(
      spender: string,
      addedValue: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    transfer(
      dst: string,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    underlying(overrides?: CallOverrides): Promise<PopulatedTransaction>;
  };
}