/* 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 MarketFacetInterface extends ethers.utils.Interface {
  functions: {
    "_supportMarket(address)": FunctionFragment;
    "accountAssets(address,uint256)": FunctionFragment;
    "actionPaused(address,uint8)": FunctionFragment;
    "addPoolMarkets(uint96[],address[])": FunctionFragment;
    "admin()": FunctionFragment;
    "allMarkets(uint256)": FunctionFragment;
    "approvedDelegates(address,address)": FunctionFragment;
    "authorizedFlashLoan(address)": FunctionFragment;
    "borrowCapGuardian()": FunctionFragment;
    "borrowCaps(address)": FunctionFragment;
    "checkMembership(address,address)": FunctionFragment;
    "closeFactorMantissa()": FunctionFragment;
    "comptrollerImplementation()": FunctionFragment;
    "comptrollerLens()": FunctionFragment;
    "corePoolId()": FunctionFragment;
    "createPool(string)": FunctionFragment;
    "enterMarketBehalf(address,address)": FunctionFragment;
    "enterMarkets(address[])": FunctionFragment;
    "enterPool(uint96)": FunctionFragment;
    "exitMarket(address)": FunctionFragment;
    "flashLoanPaused()": FunctionFragment;
    "getAllMarkets()": FunctionFragment;
    "getAssetsIn(address)": FunctionFragment;
    "getCollateralFactor(address)": FunctionFragment;
    "getEffectiveLiquidationIncentive(address,address)": FunctionFragment;
    "getEffectiveLtvFactor(address,address,uint8)": FunctionFragment;
    "getLiquidationIncentive(address)": FunctionFragment;
    "getLiquidationThreshold(address)": FunctionFragment;
    "getPoolMarketIndex(uint96,address)": FunctionFragment;
    "getPoolVTokens(uint96)": FunctionFragment;
    "getXVSAddress()": FunctionFragment;
    "hasValidPoolBorrows(address,uint96)": FunctionFragment;
    "isComptroller()": FunctionFragment;
    "isForcedLiquidationEnabled(address)": FunctionFragment;
    "isForcedLiquidationEnabledForUser(address,address)": FunctionFragment;
    "isMarketListed(address)": FunctionFragment;
    "lastPoolId()": FunctionFragment;
    "liquidateCalculateSeizeTokens(address,address,address,uint256)": FunctionFragment;
    "liquidateVAICalculateSeizeTokens(address,uint256)": FunctionFragment;
    "liquidatorContract()": FunctionFragment;
    "markets(address)": FunctionFragment;
    "maxAssets()": FunctionFragment;
    "minReleaseAmount()": FunctionFragment;
    "mintVAIGuardianPaused()": FunctionFragment;
    "mintedVAIs(address)": FunctionFragment;
    "oracle()": FunctionFragment;
    "pauseGuardian()": FunctionFragment;
    "pendingAdmin()": FunctionFragment;
    "pendingComptrollerImplementation()": FunctionFragment;
    "poolMarkets(uint96,address)": FunctionFragment;
    "pools(uint96)": FunctionFragment;
    "prime()": FunctionFragment;
    "protocolPaused()": FunctionFragment;
    "releaseStartBlock()": FunctionFragment;
    "removePoolMarket(uint96,address)": FunctionFragment;
    "repayVAIGuardianPaused()": FunctionFragment;
    "supplyCaps(address)": FunctionFragment;
    "supportMarket(address)": FunctionFragment;
    "treasuryAddress()": FunctionFragment;
    "treasuryGuardian()": FunctionFragment;
    "treasuryPercent()": FunctionFragment;
    "unlistMarket(address)": FunctionFragment;
    "updateDelegate(address,bool)": FunctionFragment;
    "userPoolId(address)": FunctionFragment;
    "vaiController()": FunctionFragment;
    "vaiMintRate()": FunctionFragment;
    "vaiVaultAddress()": FunctionFragment;
    "venusAccrued(address)": FunctionFragment;
    "venusBorrowSpeeds(address)": FunctionFragment;
    "venusBorrowState(address)": FunctionFragment;
    "venusBorrowerIndex(address,address)": FunctionFragment;
    "venusInitialIndex()": FunctionFragment;
    "venusSupplierIndex(address,address)": FunctionFragment;
    "venusSupplySpeeds(address)": FunctionFragment;
    "venusSupplyState(address)": FunctionFragment;
    "venusVAIVaultRate()": FunctionFragment;
  };

  encodeFunctionData(
    functionFragment: "_supportMarket",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "accountAssets",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "actionPaused",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "addPoolMarkets",
    values: [BigNumberish[], string[]]
  ): string;
  encodeFunctionData(functionFragment: "admin", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "allMarkets",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "approvedDelegates",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "authorizedFlashLoan",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "borrowCapGuardian",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "borrowCaps", values: [string]): string;
  encodeFunctionData(
    functionFragment: "checkMembership",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "closeFactorMantissa",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "comptrollerImplementation",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "comptrollerLens",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "corePoolId",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "createPool", values: [string]): string;
  encodeFunctionData(
    functionFragment: "enterMarketBehalf",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "enterMarkets",
    values: [string[]]
  ): string;
  encodeFunctionData(
    functionFragment: "enterPool",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "exitMarket", values: [string]): string;
  encodeFunctionData(
    functionFragment: "flashLoanPaused",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getAllMarkets",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "getAssetsIn", values: [string]): string;
  encodeFunctionData(
    functionFragment: "getCollateralFactor",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "getEffectiveLiquidationIncentive",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "getEffectiveLtvFactor",
    values: [string, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getLiquidationIncentive",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "getLiquidationThreshold",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "getPoolMarketIndex",
    values: [BigNumberish, string]
  ): string;
  encodeFunctionData(
    functionFragment: "getPoolVTokens",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getXVSAddress",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "hasValidPoolBorrows",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "isComptroller",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "isForcedLiquidationEnabled",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "isForcedLiquidationEnabledForUser",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "isMarketListed",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "lastPoolId",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "liquidateCalculateSeizeTokens",
    values: [string, string, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "liquidateVAICalculateSeizeTokens",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "liquidatorContract",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "markets", values: [string]): string;
  encodeFunctionData(functionFragment: "maxAssets", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "minReleaseAmount",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "mintVAIGuardianPaused",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "mintedVAIs", values: [string]): string;
  encodeFunctionData(functionFragment: "oracle", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "pauseGuardian",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "pendingAdmin",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "pendingComptrollerImplementation",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "poolMarkets",
    values: [BigNumberish, string]
  ): string;
  encodeFunctionData(functionFragment: "pools", values: [BigNumberish]): string;
  encodeFunctionData(functionFragment: "prime", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "protocolPaused",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "releaseStartBlock",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "removePoolMarket",
    values: [BigNumberish, string]
  ): string;
  encodeFunctionData(
    functionFragment: "repayVAIGuardianPaused",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "supplyCaps", values: [string]): string;
  encodeFunctionData(
    functionFragment: "supportMarket",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "treasuryAddress",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "treasuryGuardian",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "treasuryPercent",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "unlistMarket",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "updateDelegate",
    values: [string, boolean]
  ): string;
  encodeFunctionData(functionFragment: "userPoolId", values: [string]): string;
  encodeFunctionData(
    functionFragment: "vaiController",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "vaiMintRate",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "vaiVaultAddress",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "venusAccrued",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "venusBorrowSpeeds",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "venusBorrowState",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "venusBorrowerIndex",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "venusInitialIndex",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "venusSupplierIndex",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "venusSupplySpeeds",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "venusSupplyState",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "venusVAIVaultRate",
    values?: undefined
  ): string;

  decodeFunctionResult(
    functionFragment: "_supportMarket",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "accountAssets",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "actionPaused",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "addPoolMarkets",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "admin", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "allMarkets", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "approvedDelegates",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "authorizedFlashLoan",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "borrowCapGuardian",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "borrowCaps", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "checkMembership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "closeFactorMantissa",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "comptrollerImplementation",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "comptrollerLens",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "corePoolId", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "createPool", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "enterMarketBehalf",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "enterMarkets",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "enterPool", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "exitMarket", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "flashLoanPaused",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getAllMarkets",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getAssetsIn",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getCollateralFactor",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getEffectiveLiquidationIncentive",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getEffectiveLtvFactor",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getLiquidationIncentive",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getLiquidationThreshold",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getPoolMarketIndex",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getPoolVTokens",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getXVSAddress",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "hasValidPoolBorrows",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isComptroller",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isForcedLiquidationEnabled",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isForcedLiquidationEnabledForUser",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isMarketListed",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "lastPoolId", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "liquidateCalculateSeizeTokens",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "liquidateVAICalculateSeizeTokens",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "liquidatorContract",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "markets", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "maxAssets", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "minReleaseAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "mintVAIGuardianPaused",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "mintedVAIs", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "oracle", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "pauseGuardian",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "pendingAdmin",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "pendingComptrollerImplementation",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "poolMarkets",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "pools", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "prime", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "protocolPaused",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "releaseStartBlock",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "removePoolMarket",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "repayVAIGuardianPaused",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "supplyCaps", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "supportMarket",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "treasuryAddress",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "treasuryGuardian",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "treasuryPercent",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "unlistMarket",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateDelegate",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "userPoolId", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "vaiController",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "vaiMintRate",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "vaiVaultAddress",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "venusAccrued",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "venusBorrowSpeeds",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "venusBorrowState",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "venusBorrowerIndex",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "venusInitialIndex",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "venusSupplierIndex",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "venusSupplySpeeds",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "venusSupplyState",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "venusVAIVaultRate",
    data: BytesLike
  ): Result;

  events: {
    "DelegateUpdated(address,address,bool)": EventFragment;
    "DistributedVAIVaultVenus(uint256)": EventFragment;
    "Failure(uint256,uint256,uint256)": EventFragment;
    "MarketEntered(address,address)": EventFragment;
    "MarketExited(address,address)": EventFragment;
    "MarketListed(address)": EventFragment;
    "MarketUnlisted(address)": EventFragment;
    "PoolCreated(uint96,string)": EventFragment;
    "PoolMarketInitialized(uint96,address)": EventFragment;
    "PoolMarketRemoved(uint96,address)": EventFragment;
    "PoolSelected(address,uint96,uint96)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "DelegateUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "DistributedVAIVaultVenus"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Failure"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "MarketEntered"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "MarketExited"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "MarketListed"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "MarketUnlisted"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "PoolCreated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "PoolMarketInitialized"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "PoolMarketRemoved"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "PoolSelected"): EventFragment;
}

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

export type DistributedVAIVaultVenusEvent = TypedEvent<
  [BigNumber] & { amount: BigNumber }
>;

export type FailureEvent = TypedEvent<
  [BigNumber, BigNumber, BigNumber] & {
    error: BigNumber;
    info: BigNumber;
    detail: BigNumber;
  }
>;

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

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

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

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

export type PoolCreatedEvent = TypedEvent<
  [BigNumber, string] & { poolId: BigNumber; label: string }
>;

export type PoolMarketInitializedEvent = TypedEvent<
  [BigNumber, string] & { poolId: BigNumber; market: string }
>;

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

export type PoolSelectedEvent = TypedEvent<
  [string, BigNumber, BigNumber] & {
    account: string;
    previousPoolId: BigNumber;
    newPoolId: BigNumber;
  }
>;

export class MarketFacet 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: MarketFacetInterface;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    getCollateralFactor(
      vToken: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

    getEffectiveLtvFactor(
      account: string,
      vToken: string,
      weightingStrategy: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    getLiquidationIncentive(
      vToken: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    getLiquidationThreshold(
      vToken: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    getPoolMarketIndex(
      poolId: BigNumberish,
      vToken: string,
      overrides?: CallOverrides
    ): Promise<[string]>;

    getPoolVTokens(
      poolId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[string[]]>;

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

    hasValidPoolBorrows(
      account: string,
      targetPoolId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

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

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

    isForcedLiquidationEnabledForUser(
      user: string,
      market: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

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

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

    "liquidateCalculateSeizeTokens(address,address,address,uint256)"(
      borrower: string,
      vTokenBorrowed: string,
      vTokenCollateral: string,
      actualRepayAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber, BigNumber]>;

    "liquidateCalculateSeizeTokens(address,address,uint256)"(
      vTokenBorrowed: string,
      vTokenCollateral: string,
      actualRepayAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber, BigNumber]>;

    liquidateVAICalculateSeizeTokens(
      vTokenCollateral: string,
      actualRepayAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber, BigNumber]>;

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

    markets(
      vToken: string,
      overrides?: CallOverrides
    ): Promise<
      [
        boolean,
        BigNumber,
        boolean,
        BigNumber,
        BigNumber,
        BigNumber,
        boolean
      ] & {
        isListed: boolean;
        collateralFactorMantissa: BigNumber;
        isVenus: boolean;
        liquidationThresholdMantissa: BigNumber;
        liquidationIncentiveMantissa: BigNumber;
        marketPoolId: BigNumber;
        isBorrowAllowed: boolean;
      }
    >;

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

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

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

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

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

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

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

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

    poolMarkets(
      poolId: BigNumberish,
      vToken: string,
      overrides?: CallOverrides
    ): Promise<
      [
        boolean,
        BigNumber,
        boolean,
        BigNumber,
        BigNumber,
        BigNumber,
        boolean
      ] & {
        isListed: boolean;
        collateralFactorMantissa: BigNumber;
        isVenus: boolean;
        liquidationThresholdMantissa: BigNumber;
        liquidationIncentiveMantissa: BigNumber;
        marketPoolId: BigNumber;
        isBorrowAllowed: boolean;
      }
    >;

    pools(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [string, boolean, boolean] & {
        label: string;
        isActive: boolean;
        allowCorePoolFallback: boolean;
      }
    >;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    venusBorrowState(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber, number] & { index: BigNumber; block: number }>;

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

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

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

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

    venusSupplyState(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber, number] & { index: BigNumber; block: number }>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  getEffectiveLtvFactor(
    account: string,
    vToken: string,
    weightingStrategy: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

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

  getPoolMarketIndex(
    poolId: BigNumberish,
    vToken: string,
    overrides?: CallOverrides
  ): Promise<string>;

  getPoolVTokens(
    poolId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<string[]>;

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

  hasValidPoolBorrows(
    account: string,
    targetPoolId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<boolean>;

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

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

  isForcedLiquidationEnabledForUser(
    user: string,
    market: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

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

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

  "liquidateCalculateSeizeTokens(address,address,address,uint256)"(
    borrower: string,
    vTokenBorrowed: string,
    vTokenCollateral: string,
    actualRepayAmount: BigNumberish,
    overrides?: CallOverrides
  ): Promise<[BigNumber, BigNumber]>;

  "liquidateCalculateSeizeTokens(address,address,uint256)"(
    vTokenBorrowed: string,
    vTokenCollateral: string,
    actualRepayAmount: BigNumberish,
    overrides?: CallOverrides
  ): Promise<[BigNumber, BigNumber]>;

  liquidateVAICalculateSeizeTokens(
    vTokenCollateral: string,
    actualRepayAmount: BigNumberish,
    overrides?: CallOverrides
  ): Promise<[BigNumber, BigNumber]>;

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

  markets(
    vToken: string,
    overrides?: CallOverrides
  ): Promise<
    [boolean, BigNumber, boolean, BigNumber, BigNumber, BigNumber, boolean] & {
      isListed: boolean;
      collateralFactorMantissa: BigNumber;
      isVenus: boolean;
      liquidationThresholdMantissa: BigNumber;
      liquidationIncentiveMantissa: BigNumber;
      marketPoolId: BigNumber;
      isBorrowAllowed: boolean;
    }
  >;

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

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

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

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

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

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

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

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

  poolMarkets(
    poolId: BigNumberish,
    vToken: string,
    overrides?: CallOverrides
  ): Promise<
    [boolean, BigNumber, boolean, BigNumber, BigNumber, BigNumber, boolean] & {
      isListed: boolean;
      collateralFactorMantissa: BigNumber;
      isVenus: boolean;
      liquidationThresholdMantissa: BigNumber;
      liquidationIncentiveMantissa: BigNumber;
      marketPoolId: BigNumber;
      isBorrowAllowed: boolean;
    }
  >;

  pools(
    arg0: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    [string, boolean, boolean] & {
      label: string;
      isActive: boolean;
      allowCorePoolFallback: boolean;
    }
  >;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  venusBorrowState(
    arg0: string,
    overrides?: CallOverrides
  ): Promise<[BigNumber, number] & { index: BigNumber; block: number }>;

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

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

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

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

  venusSupplyState(
    arg0: string,
    overrides?: CallOverrides
  ): Promise<[BigNumber, number] & { index: BigNumber; block: number }>;

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

  callStatic: {
    _supportMarket(
      vToken: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    createPool(label: string, overrides?: CallOverrides): Promise<BigNumber>;

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

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

    enterPool(poolId: BigNumberish, overrides?: CallOverrides): Promise<void>;

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

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

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

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

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

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

    getEffectiveLtvFactor(
      account: string,
      vToken: string,
      weightingStrategy: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    getPoolMarketIndex(
      poolId: BigNumberish,
      vToken: string,
      overrides?: CallOverrides
    ): Promise<string>;

    getPoolVTokens(
      poolId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string[]>;

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

    hasValidPoolBorrows(
      account: string,
      targetPoolId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

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

    isForcedLiquidationEnabledForUser(
      user: string,
      market: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

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

    "liquidateCalculateSeizeTokens(address,address,address,uint256)"(
      borrower: string,
      vTokenBorrowed: string,
      vTokenCollateral: string,
      actualRepayAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber, BigNumber]>;

    "liquidateCalculateSeizeTokens(address,address,uint256)"(
      vTokenBorrowed: string,
      vTokenCollateral: string,
      actualRepayAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber, BigNumber]>;

    liquidateVAICalculateSeizeTokens(
      vTokenCollateral: string,
      actualRepayAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber, BigNumber]>;

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

    markets(
      vToken: string,
      overrides?: CallOverrides
    ): Promise<
      [
        boolean,
        BigNumber,
        boolean,
        BigNumber,
        BigNumber,
        BigNumber,
        boolean
      ] & {
        isListed: boolean;
        collateralFactorMantissa: BigNumber;
        isVenus: boolean;
        liquidationThresholdMantissa: BigNumber;
        liquidationIncentiveMantissa: BigNumber;
        marketPoolId: BigNumber;
        isBorrowAllowed: boolean;
      }
    >;

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

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

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

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

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

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

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

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

    poolMarkets(
      poolId: BigNumberish,
      vToken: string,
      overrides?: CallOverrides
    ): Promise<
      [
        boolean,
        BigNumber,
        boolean,
        BigNumber,
        BigNumber,
        BigNumber,
        boolean
      ] & {
        isListed: boolean;
        collateralFactorMantissa: BigNumber;
        isVenus: boolean;
        liquidationThresholdMantissa: BigNumber;
        liquidationIncentiveMantissa: BigNumber;
        marketPoolId: BigNumber;
        isBorrowAllowed: boolean;
      }
    >;

    pools(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [string, boolean, boolean] & {
        label: string;
        isActive: boolean;
        allowCorePoolFallback: boolean;
      }
    >;

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

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

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

    removePoolMarket(
      poolId: BigNumberish,
      vToken: string,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    venusBorrowState(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber, number] & { index: BigNumber; block: number }>;

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

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

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

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

    venusSupplyState(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber, number] & { index: BigNumber; block: number }>;

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

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

    "DistributedVAIVaultVenus(uint256)"(
      amount?: null
    ): TypedEventFilter<[BigNumber], { amount: BigNumber }>;

    DistributedVAIVaultVenus(
      amount?: null
    ): TypedEventFilter<[BigNumber], { amount: BigNumber }>;

    "Failure(uint256,uint256,uint256)"(
      error?: null,
      info?: null,
      detail?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber, BigNumber],
      { error: BigNumber; info: BigNumber; detail: BigNumber }
    >;

    Failure(
      error?: null,
      info?: null,
      detail?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber, BigNumber],
      { error: BigNumber; info: BigNumber; detail: BigNumber }
    >;

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

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

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

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

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

    "PoolCreated(uint96,string)"(
      poolId?: BigNumberish | null,
      label?: null
    ): TypedEventFilter<
      [BigNumber, string],
      { poolId: BigNumber; label: string }
    >;

    PoolCreated(
      poolId?: BigNumberish | null,
      label?: null
    ): TypedEventFilter<
      [BigNumber, string],
      { poolId: BigNumber; label: string }
    >;

    "PoolMarketInitialized(uint96,address)"(
      poolId?: BigNumberish | null,
      market?: string | null
    ): TypedEventFilter<
      [BigNumber, string],
      { poolId: BigNumber; market: string }
    >;

    PoolMarketInitialized(
      poolId?: BigNumberish | null,
      market?: string | null
    ): TypedEventFilter<
      [BigNumber, string],
      { poolId: BigNumber; market: string }
    >;

    "PoolMarketRemoved(uint96,address)"(
      poolId?: BigNumberish | null,
      vToken?: string | null
    ): TypedEventFilter<
      [BigNumber, string],
      { poolId: BigNumber; vToken: string }
    >;

    PoolMarketRemoved(
      poolId?: BigNumberish | null,
      vToken?: string | null
    ): TypedEventFilter<
      [BigNumber, string],
      { poolId: BigNumber; vToken: string }
    >;

    "PoolSelected(address,uint96,uint96)"(
      account?: string | null,
      previousPoolId?: null,
      newPoolId?: BigNumberish | null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber],
      { account: string; previousPoolId: BigNumber; newPoolId: BigNumber }
    >;

    PoolSelected(
      account?: string | null,
      previousPoolId?: null,
      newPoolId?: BigNumberish | null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber],
      { account: string; previousPoolId: BigNumber; newPoolId: BigNumber }
    >;
  };

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    getEffectiveLtvFactor(
      account: string,
      vToken: string,
      weightingStrategy: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    getPoolMarketIndex(
      poolId: BigNumberish,
      vToken: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getPoolVTokens(
      poolId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    hasValidPoolBorrows(
      account: string,
      targetPoolId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    poolMarkets(
      poolId: BigNumberish,
      vToken: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

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

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

    treasuryPercent(overrides?: CallOverrides): 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>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    getEffectiveLtvFactor(
      account: string,
      vToken: string,
      weightingStrategy: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    getPoolMarketIndex(
      poolId: BigNumberish,
      vToken: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getPoolVTokens(
      poolId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    hasValidPoolBorrows(
      account: string,
      targetPoolId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    isForcedLiquidationEnabledForUser(
      user: string,
      market: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    poolMarkets(
      poolId: BigNumberish,
      vToken: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

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

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

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

    treasuryPercent(overrides?: CallOverrides): 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>;

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

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

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

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

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

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

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

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

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

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

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

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

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