/* 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 SetterFacetInterface extends ethers.utils.Interface {
  functions: {
    "_setAccessControl(address)": FunctionFragment;
    "_setActionsPaused(address[],uint8[],bool)": FunctionFragment;
    "_setCloseFactor(uint256)": FunctionFragment;
    "_setComptrollerLens(address)": FunctionFragment;
    "_setForcedLiquidation(address,bool)": FunctionFragment;
    "_setForcedLiquidationForUser(address,address,bool)": FunctionFragment;
    "_setLiquidatorContract(address)": FunctionFragment;
    "_setMarketBorrowCaps(address[],uint256[])": FunctionFragment;
    "_setMarketSupplyCaps(address[],uint256[])": FunctionFragment;
    "_setPauseGuardian(address)": FunctionFragment;
    "_setPriceOracle(address)": FunctionFragment;
    "_setPrimeToken(address)": FunctionFragment;
    "_setProtocolPaused(bool)": FunctionFragment;
    "_setTreasuryData(address,address,uint256)": FunctionFragment;
    "_setVAIController(address)": FunctionFragment;
    "_setVAIMintRate(uint256)": FunctionFragment;
    "_setVAIVaultInfo(address,uint256,uint256)": FunctionFragment;
    "_setVenusVAIVaultRate(uint256)": FunctionFragment;
    "_setXVSToken(address)": FunctionFragment;
    "_setXVSVToken(address)": FunctionFragment;
    "accountAssets(address,uint256)": FunctionFragment;
    "actionPaused(address,uint8)": FunctionFragment;
    "admin()": FunctionFragment;
    "allMarkets(uint256)": FunctionFragment;
    "approvedDelegates(address,address)": FunctionFragment;
    "authorizedFlashLoan(address)": FunctionFragment;
    "borrowCapGuardian()": FunctionFragment;
    "borrowCaps(address)": FunctionFragment;
    "closeFactorMantissa()": FunctionFragment;
    "comptrollerImplementation()": FunctionFragment;
    "comptrollerLens()": FunctionFragment;
    "corePoolId()": FunctionFragment;
    "flashLoanPaused()": FunctionFragment;
    "getPoolMarketIndex(uint96,address)": FunctionFragment;
    "getXVSAddress()": FunctionFragment;
    "isForcedLiquidationEnabled(address)": FunctionFragment;
    "isForcedLiquidationEnabledForUser(address,address)": FunctionFragment;
    "lastPoolId()": FunctionFragment;
    "liquidatorContract()": FunctionFragment;
    "maxAssets()": FunctionFragment;
    "minReleaseAmount()": FunctionFragment;
    "mintVAIGuardianPaused()": FunctionFragment;
    "mintedVAIs(address)": FunctionFragment;
    "oracle()": FunctionFragment;
    "pauseGuardian()": FunctionFragment;
    "pendingAdmin()": FunctionFragment;
    "pendingComptrollerImplementation()": FunctionFragment;
    "pools(uint96)": FunctionFragment;
    "prime()": FunctionFragment;
    "protocolPaused()": FunctionFragment;
    "releaseStartBlock()": FunctionFragment;
    "repayVAIGuardianPaused()": FunctionFragment;
    "setActionsPaused(address[],uint8[],bool)": FunctionFragment;
    "setAllowCorePoolFallback(uint96,bool)": FunctionFragment;
    "setCloseFactor(uint256)": FunctionFragment;
    "setCollateralFactor(address,uint256,uint256)": FunctionFragment;
    "setFlashLoanPaused(bool)": FunctionFragment;
    "setForcedLiquidation(address,bool)": FunctionFragment;
    "setIsBorrowAllowed(uint96,address,bool)": FunctionFragment;
    "setLiquidationIncentive(uint96,address,uint256)": FunctionFragment;
    "setMarketBorrowCaps(address[],uint256[])": FunctionFragment;
    "setMarketSupplyCaps(address[],uint256[])": FunctionFragment;
    "setMintedVAIOf(address,uint256)": FunctionFragment;
    "setPoolActive(uint96,bool)": FunctionFragment;
    "setPoolLabel(uint96,string)": FunctionFragment;
    "setPriceOracle(address)": FunctionFragment;
    "setPrimeToken(address)": FunctionFragment;
    "setWhiteListFlashLoanAccount(address,bool)": FunctionFragment;
    "supplyCaps(address)": FunctionFragment;
    "treasuryAddress()": FunctionFragment;
    "treasuryGuardian()": FunctionFragment;
    "treasuryPercent()": 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: "_setAccessControl",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "_setActionsPaused",
    values: [string[], BigNumberish[], boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "_setCloseFactor",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "_setComptrollerLens",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "_setForcedLiquidation",
    values: [string, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "_setForcedLiquidationForUser",
    values: [string, string, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "_setLiquidatorContract",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "_setMarketBorrowCaps",
    values: [string[], BigNumberish[]]
  ): string;
  encodeFunctionData(
    functionFragment: "_setMarketSupplyCaps",
    values: [string[], BigNumberish[]]
  ): string;
  encodeFunctionData(
    functionFragment: "_setPauseGuardian",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "_setPriceOracle",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "_setPrimeToken",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "_setProtocolPaused",
    values: [boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "_setTreasuryData",
    values: [string, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "_setVAIController",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "_setVAIMintRate",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "_setVAIVaultInfo",
    values: [string, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "_setVenusVAIVaultRate",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "_setXVSToken",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "_setXVSVToken",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "accountAssets",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "actionPaused",
    values: [string, BigNumberish]
  ): 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: "closeFactorMantissa",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "comptrollerImplementation",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "comptrollerLens",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "corePoolId",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "flashLoanPaused",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getPoolMarketIndex",
    values: [BigNumberish, string]
  ): string;
  encodeFunctionData(
    functionFragment: "getXVSAddress",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "isForcedLiquidationEnabled",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "isForcedLiquidationEnabledForUser",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "lastPoolId",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "liquidatorContract",
    values?: undefined
  ): 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: "pools", values: [BigNumberish]): string;
  encodeFunctionData(functionFragment: "prime", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "protocolPaused",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "releaseStartBlock",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "repayVAIGuardianPaused",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "setActionsPaused",
    values: [string[], BigNumberish[], boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "setAllowCorePoolFallback",
    values: [BigNumberish, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "setCloseFactor",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setCollateralFactor",
    values: [string, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setFlashLoanPaused",
    values: [boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "setForcedLiquidation",
    values: [string, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "setIsBorrowAllowed",
    values: [BigNumberish, string, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "setLiquidationIncentive",
    values: [BigNumberish, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setMarketBorrowCaps",
    values: [string[], BigNumberish[]]
  ): string;
  encodeFunctionData(
    functionFragment: "setMarketSupplyCaps",
    values: [string[], BigNumberish[]]
  ): string;
  encodeFunctionData(
    functionFragment: "setMintedVAIOf",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setPoolActive",
    values: [BigNumberish, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "setPoolLabel",
    values: [BigNumberish, string]
  ): string;
  encodeFunctionData(
    functionFragment: "setPriceOracle",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setPrimeToken",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setWhiteListFlashLoanAccount",
    values: [string, boolean]
  ): string;
  encodeFunctionData(functionFragment: "supplyCaps", values: [string]): string;
  encodeFunctionData(
    functionFragment: "treasuryAddress",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "treasuryGuardian",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "treasuryPercent",
    values?: undefined
  ): 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: "_setAccessControl",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "_setActionsPaused",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "_setCloseFactor",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "_setComptrollerLens",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "_setForcedLiquidation",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "_setForcedLiquidationForUser",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "_setLiquidatorContract",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "_setMarketBorrowCaps",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "_setMarketSupplyCaps",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "_setPauseGuardian",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "_setPriceOracle",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "_setPrimeToken",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "_setProtocolPaused",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "_setTreasuryData",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "_setVAIController",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "_setVAIMintRate",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "_setVAIVaultInfo",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "_setVenusVAIVaultRate",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "_setXVSToken",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "_setXVSVToken",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "accountAssets",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "actionPaused",
    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: "closeFactorMantissa",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "comptrollerImplementation",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "comptrollerLens",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "corePoolId", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "flashLoanPaused",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getPoolMarketIndex",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getXVSAddress",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isForcedLiquidationEnabled",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isForcedLiquidationEnabledForUser",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "lastPoolId", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "liquidatorContract",
    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: "pools", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "prime", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "protocolPaused",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "releaseStartBlock",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "repayVAIGuardianPaused",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setActionsPaused",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setAllowCorePoolFallback",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setCloseFactor",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setCollateralFactor",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setFlashLoanPaused",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setForcedLiquidation",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setIsBorrowAllowed",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setLiquidationIncentive",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setMarketBorrowCaps",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setMarketSupplyCaps",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setMintedVAIOf",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setPoolActive",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setPoolLabel",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setPriceOracle",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setPrimeToken",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setWhiteListFlashLoanAccount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "supplyCaps", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "treasuryAddress",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "treasuryGuardian",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "treasuryPercent",
    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: {
    "ActionPausedMarket(address,uint8,bool)": EventFragment;
    "ActionProtocolPaused(bool)": EventFragment;
    "BorrowAllowedUpdated(uint96,address,bool,bool)": EventFragment;
    "DistributedVAIVaultVenus(uint256)": EventFragment;
    "Failure(uint256,uint256,uint256)": EventFragment;
    "FlashLoanPauseChanged(bool,bool)": EventFragment;
    "IsAccountFlashLoanWhitelisted(address,bool)": EventFragment;
    "IsForcedLiquidationEnabledForUserUpdated(address,address,bool)": EventFragment;
    "IsForcedLiquidationEnabledUpdated(address,bool)": EventFragment;
    "MarketEntered(address,address)": EventFragment;
    "NewAccessControl(address,address)": EventFragment;
    "NewBorrowCap(address,uint256)": EventFragment;
    "NewCloseFactor(uint256,uint256)": EventFragment;
    "NewCollateralFactor(uint96,address,uint256,uint256)": EventFragment;
    "NewComptrollerLens(address,address)": EventFragment;
    "NewLiquidationIncentive(uint96,address,uint256,uint256)": EventFragment;
    "NewLiquidationThreshold(uint96,address,uint256,uint256)": EventFragment;
    "NewLiquidatorContract(address,address)": EventFragment;
    "NewPauseGuardian(address,address)": EventFragment;
    "NewPriceOracle(address,address)": EventFragment;
    "NewPrimeToken(address,address)": EventFragment;
    "NewSupplyCap(address,uint256)": EventFragment;
    "NewTreasuryAddress(address,address)": EventFragment;
    "NewTreasuryGuardian(address,address)": EventFragment;
    "NewTreasuryPercent(uint256,uint256)": EventFragment;
    "NewVAIController(address,address)": EventFragment;
    "NewVAIMintRate(uint256,uint256)": EventFragment;
    "NewVAIVaultInfo(address,uint256,uint256)": EventFragment;
    "NewVenusVAIVaultRate(uint256,uint256)": EventFragment;
    "NewXVSToken(address,address)": EventFragment;
    "NewXVSVToken(address,address)": EventFragment;
    "PoolActiveStatusUpdated(uint96,bool,bool)": EventFragment;
    "PoolFallbackStatusUpdated(uint96,bool,bool)": EventFragment;
    "PoolLabelUpdated(uint96,string,string)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "ActionPausedMarket"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ActionProtocolPaused"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "BorrowAllowedUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "DistributedVAIVaultVenus"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Failure"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "FlashLoanPauseChanged"): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "IsAccountFlashLoanWhitelisted"
  ): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "IsForcedLiquidationEnabledForUserUpdated"
  ): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "IsForcedLiquidationEnabledUpdated"
  ): EventFragment;
  getEvent(nameOrSignatureOrTopic: "MarketEntered"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewAccessControl"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewBorrowCap"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewCloseFactor"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewCollateralFactor"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewComptrollerLens"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewLiquidationIncentive"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewLiquidationThreshold"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewLiquidatorContract"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewPauseGuardian"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewPriceOracle"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewPrimeToken"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewSupplyCap"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewTreasuryAddress"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewTreasuryGuardian"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewTreasuryPercent"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewVAIController"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewVAIMintRate"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewVAIVaultInfo"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewVenusVAIVaultRate"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewXVSToken"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewXVSVToken"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "PoolActiveStatusUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "PoolFallbackStatusUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "PoolLabelUpdated"): EventFragment;
}

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

export type ActionProtocolPausedEvent = TypedEvent<
  [boolean] & { state: boolean }
>;

export type BorrowAllowedUpdatedEvent = TypedEvent<
  [BigNumber, string, boolean, boolean] & {
    poolId: BigNumber;
    market: string;
    oldStatus: boolean;
    newStatus: boolean;
  }
>;

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

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

export type FlashLoanPauseChangedEvent = TypedEvent<
  [boolean, boolean] & { oldPaused: boolean; newPaused: boolean }
>;

export type IsAccountFlashLoanWhitelistedEvent = TypedEvent<
  [string, boolean] & { account: string; isWhitelisted: boolean }
>;

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

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

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

export type NewAccessControlEvent = TypedEvent<
  [string, string] & {
    oldAccessControlAddress: string;
    newAccessControlAddress: string;
  }
>;

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

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

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

export type NewComptrollerLensEvent = TypedEvent<
  [string, string] & { oldComptrollerLens: string; newComptrollerLens: string }
>;

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

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

export type NewLiquidatorContractEvent = TypedEvent<
  [string, string] & {
    oldLiquidatorContract: string;
    newLiquidatorContract: string;
  }
>;

export type NewPauseGuardianEvent = TypedEvent<
  [string, string] & { oldPauseGuardian: string; newPauseGuardian: string }
>;

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

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

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

export type NewTreasuryAddressEvent = TypedEvent<
  [string, string] & { oldTreasuryAddress: string; newTreasuryAddress: string }
>;

export type NewTreasuryGuardianEvent = TypedEvent<
  [string, string] & {
    oldTreasuryGuardian: string;
    newTreasuryGuardian: string;
  }
>;

export type NewTreasuryPercentEvent = TypedEvent<
  [BigNumber, BigNumber] & {
    oldTreasuryPercent: BigNumber;
    newTreasuryPercent: BigNumber;
  }
>;

export type NewVAIControllerEvent = TypedEvent<
  [string, string] & { oldVAIController: string; newVAIController: string }
>;

export type NewVAIMintRateEvent = TypedEvent<
  [BigNumber, BigNumber] & {
    oldVAIMintRate: BigNumber;
    newVAIMintRate: BigNumber;
  }
>;

export type NewVAIVaultInfoEvent = TypedEvent<
  [string, BigNumber, BigNumber] & {
    vault_: string;
    releaseStartBlock_: BigNumber;
    releaseInterval_: BigNumber;
  }
>;

export type NewVenusVAIVaultRateEvent = TypedEvent<
  [BigNumber, BigNumber] & {
    oldVenusVAIVaultRate: BigNumber;
    newVenusVAIVaultRate: BigNumber;
  }
>;

export type NewXVSTokenEvent = TypedEvent<
  [string, string] & { oldXVS: string; newXVS: string }
>;

export type NewXVSVTokenEvent = TypedEvent<
  [string, string] & { oldXVSVToken: string; newXVSVToken: string }
>;

export type PoolActiveStatusUpdatedEvent = TypedEvent<
  [BigNumber, boolean, boolean] & {
    poolId: BigNumber;
    oldStatus: boolean;
    newStatus: boolean;
  }
>;

export type PoolFallbackStatusUpdatedEvent = TypedEvent<
  [BigNumber, boolean, boolean] & {
    poolId: BigNumber;
    oldStatus: boolean;
    newStatus: boolean;
  }
>;

export type PoolLabelUpdatedEvent = TypedEvent<
  [BigNumber, string, string] & {
    poolId: BigNumber;
    oldLabel: string;
    newLabel: string;
  }
>;

export class SetterFacet 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: SetterFacetInterface;

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

    _setActionsPaused(
      markets_: string[],
      actions_: BigNumberish[],
      paused_: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

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

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

    _setProtocolPaused(
      state: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    _setTreasuryData(
      newTreasuryGuardian: string,
      newTreasuryAddress: string,
      newTreasuryPercent: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

    _setVAIVaultInfo(
      vault_: string,
      releaseStartBlock_: BigNumberish,
      minReleaseAmount_: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

    _setXVSVToken(
      xvsVToken_: 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]>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    setActionsPaused(
      markets_: string[],
      actions_: BigNumberish[],
      paused_: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

    setFlashLoanPaused(
      paused: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

    "setLiquidationIncentive(uint96,address,uint256)"(
      poolId: BigNumberish,
      vToken: string,
      newLiquidationIncentiveMantissa: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  _setActionsPaused(
    markets_: string[],
    actions_: BigNumberish[],
    paused_: boolean,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

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

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

  _setProtocolPaused(
    state: boolean,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  _setTreasuryData(
    newTreasuryGuardian: string,
    newTreasuryAddress: string,
    newTreasuryPercent: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

  _setVAIVaultInfo(
    vault_: string,
    releaseStartBlock_: BigNumberish,
    minReleaseAmount_: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

  _setXVSVToken(
    xvsVToken_: 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>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  setActionsPaused(
    markets_: string[],
    actions_: BigNumberish[],
    paused_: boolean,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

  setFlashLoanPaused(
    paused: boolean,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

  "setLiquidationIncentive(uint96,address,uint256)"(
    poolId: BigNumberish,
    vToken: string,
    newLiquidationIncentiveMantissa: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

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

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

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

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

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

  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: {
    _setAccessControl(
      newAccessControlAddress: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    _setActionsPaused(
      markets_: string[],
      actions_: BigNumberish[],
      paused_: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

    _setCloseFactor(
      newCloseFactorMantissa: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    _setComptrollerLens(
      comptrollerLens_: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    _setLiquidatorContract(
      newLiquidatorContract_: string,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    _setPauseGuardian(
      newPauseGuardian: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    _setPriceOracle(
      newOracle: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    _setPrimeToken(
      _prime: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    _setProtocolPaused(
      state: boolean,
      overrides?: CallOverrides
    ): Promise<boolean>;

    _setTreasuryData(
      newTreasuryGuardian: string,
      newTreasuryAddress: string,
      newTreasuryPercent: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    _setVAIController(
      vaiController_: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    _setVAIMintRate(
      newVAIMintRate: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    _setVAIVaultInfo(
      vault_: string,
      releaseStartBlock_: BigNumberish,
      minReleaseAmount_: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    _setVenusVAIVaultRate(
      venusVAIVaultRate_: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    _setXVSToken(xvs_: string, overrides?: CallOverrides): Promise<void>;

    _setXVSVToken(xvsVToken_: string, overrides?: CallOverrides): Promise<void>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    setActionsPaused(
      markets_: string[],
      actions_: BigNumberish[],
      paused_: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

    setAllowCorePoolFallback(
      poolId: BigNumberish,
      allowFallback: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

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

    "setCollateralFactor(address,uint256,uint256)"(
      vToken: string,
      newCollateralFactorMantissa: BigNumberish,
      newLiquidationThresholdMantissa: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "setCollateralFactor(uint96,address,uint256,uint256)"(
      poolId: BigNumberish,
      vToken: string,
      newCollateralFactorMantissa: BigNumberish,
      newLiquidationThresholdMantissa: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    setFlashLoanPaused(
      paused: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    "setLiquidationIncentive(uint96,address,uint256)"(
      poolId: BigNumberish,
      vToken: string,
      newLiquidationIncentiveMantissa: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "setLiquidationIncentive(address,uint256)"(
      vToken: string,
      newLiquidationIncentiveMantissa: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    setMintedVAIOf(
      owner: string,
      amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    setPoolActive(
      poolId: BigNumberish,
      active: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

    setPoolLabel(
      poolId: BigNumberish,
      newLabel: string,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    setWhiteListFlashLoanAccount(
      account: string,
      isWhiteListed: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

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

    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: {
    "ActionPausedMarket(address,uint8,bool)"(
      vToken?: string | null,
      action?: BigNumberish | null,
      pauseState?: null
    ): TypedEventFilter<
      [string, number, boolean],
      { vToken: string; action: number; pauseState: boolean }
    >;

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

    "ActionProtocolPaused(bool)"(
      state?: null
    ): TypedEventFilter<[boolean], { state: boolean }>;

    ActionProtocolPaused(
      state?: null
    ): TypedEventFilter<[boolean], { state: boolean }>;

    "BorrowAllowedUpdated(uint96,address,bool,bool)"(
      poolId?: BigNumberish | null,
      market?: string | null,
      oldStatus?: null,
      newStatus?: null
    ): TypedEventFilter<
      [BigNumber, string, boolean, boolean],
      {
        poolId: BigNumber;
        market: string;
        oldStatus: boolean;
        newStatus: boolean;
      }
    >;

    BorrowAllowedUpdated(
      poolId?: BigNumberish | null,
      market?: string | null,
      oldStatus?: null,
      newStatus?: null
    ): TypedEventFilter<
      [BigNumber, string, boolean, boolean],
      {
        poolId: BigNumber;
        market: string;
        oldStatus: boolean;
        newStatus: 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 }
    >;

    "FlashLoanPauseChanged(bool,bool)"(
      oldPaused?: null,
      newPaused?: null
    ): TypedEventFilter<
      [boolean, boolean],
      { oldPaused: boolean; newPaused: boolean }
    >;

    FlashLoanPauseChanged(
      oldPaused?: null,
      newPaused?: null
    ): TypedEventFilter<
      [boolean, boolean],
      { oldPaused: boolean; newPaused: boolean }
    >;

    "IsAccountFlashLoanWhitelisted(address,bool)"(
      account?: string | null,
      isWhitelisted?: boolean | null
    ): TypedEventFilter<
      [string, boolean],
      { account: string; isWhitelisted: boolean }
    >;

    IsAccountFlashLoanWhitelisted(
      account?: string | null,
      isWhitelisted?: boolean | null
    ): TypedEventFilter<
      [string, boolean],
      { account: string; isWhitelisted: boolean }
    >;

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

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

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

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

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

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

    "NewAccessControl(address,address)"(
      oldAccessControlAddress?: null,
      newAccessControlAddress?: null
    ): TypedEventFilter<
      [string, string],
      { oldAccessControlAddress: string; newAccessControlAddress: string }
    >;

    NewAccessControl(
      oldAccessControlAddress?: null,
      newAccessControlAddress?: null
    ): TypedEventFilter<
      [string, string],
      { oldAccessControlAddress: string; newAccessControlAddress: string }
    >;

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

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

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

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

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

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

    "NewComptrollerLens(address,address)"(
      oldComptrollerLens?: null,
      newComptrollerLens?: null
    ): TypedEventFilter<
      [string, string],
      { oldComptrollerLens: string; newComptrollerLens: string }
    >;

    NewComptrollerLens(
      oldComptrollerLens?: null,
      newComptrollerLens?: null
    ): TypedEventFilter<
      [string, string],
      { oldComptrollerLens: string; newComptrollerLens: string }
    >;

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

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

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

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

    "NewLiquidatorContract(address,address)"(
      oldLiquidatorContract?: null,
      newLiquidatorContract?: null
    ): TypedEventFilter<
      [string, string],
      { oldLiquidatorContract: string; newLiquidatorContract: string }
    >;

    NewLiquidatorContract(
      oldLiquidatorContract?: null,
      newLiquidatorContract?: null
    ): TypedEventFilter<
      [string, string],
      { oldLiquidatorContract: string; newLiquidatorContract: string }
    >;

    "NewPauseGuardian(address,address)"(
      oldPauseGuardian?: null,
      newPauseGuardian?: null
    ): TypedEventFilter<
      [string, string],
      { oldPauseGuardian: string; newPauseGuardian: string }
    >;

    NewPauseGuardian(
      oldPauseGuardian?: null,
      newPauseGuardian?: null
    ): TypedEventFilter<
      [string, string],
      { oldPauseGuardian: string; newPauseGuardian: string }
    >;

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

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

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

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

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

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

    "NewTreasuryAddress(address,address)"(
      oldTreasuryAddress?: null,
      newTreasuryAddress?: null
    ): TypedEventFilter<
      [string, string],
      { oldTreasuryAddress: string; newTreasuryAddress: string }
    >;

    NewTreasuryAddress(
      oldTreasuryAddress?: null,
      newTreasuryAddress?: null
    ): TypedEventFilter<
      [string, string],
      { oldTreasuryAddress: string; newTreasuryAddress: string }
    >;

    "NewTreasuryGuardian(address,address)"(
      oldTreasuryGuardian?: null,
      newTreasuryGuardian?: null
    ): TypedEventFilter<
      [string, string],
      { oldTreasuryGuardian: string; newTreasuryGuardian: string }
    >;

    NewTreasuryGuardian(
      oldTreasuryGuardian?: null,
      newTreasuryGuardian?: null
    ): TypedEventFilter<
      [string, string],
      { oldTreasuryGuardian: string; newTreasuryGuardian: string }
    >;

    "NewTreasuryPercent(uint256,uint256)"(
      oldTreasuryPercent?: null,
      newTreasuryPercent?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber],
      { oldTreasuryPercent: BigNumber; newTreasuryPercent: BigNumber }
    >;

    NewTreasuryPercent(
      oldTreasuryPercent?: null,
      newTreasuryPercent?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber],
      { oldTreasuryPercent: BigNumber; newTreasuryPercent: BigNumber }
    >;

    "NewVAIController(address,address)"(
      oldVAIController?: null,
      newVAIController?: null
    ): TypedEventFilter<
      [string, string],
      { oldVAIController: string; newVAIController: string }
    >;

    NewVAIController(
      oldVAIController?: null,
      newVAIController?: null
    ): TypedEventFilter<
      [string, string],
      { oldVAIController: string; newVAIController: string }
    >;

    "NewVAIMintRate(uint256,uint256)"(
      oldVAIMintRate?: null,
      newVAIMintRate?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber],
      { oldVAIMintRate: BigNumber; newVAIMintRate: BigNumber }
    >;

    NewVAIMintRate(
      oldVAIMintRate?: null,
      newVAIMintRate?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber],
      { oldVAIMintRate: BigNumber; newVAIMintRate: BigNumber }
    >;

    "NewVAIVaultInfo(address,uint256,uint256)"(
      vault_?: string | null,
      releaseStartBlock_?: null,
      releaseInterval_?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber],
      {
        vault_: string;
        releaseStartBlock_: BigNumber;
        releaseInterval_: BigNumber;
      }
    >;

    NewVAIVaultInfo(
      vault_?: string | null,
      releaseStartBlock_?: null,
      releaseInterval_?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber],
      {
        vault_: string;
        releaseStartBlock_: BigNumber;
        releaseInterval_: BigNumber;
      }
    >;

    "NewVenusVAIVaultRate(uint256,uint256)"(
      oldVenusVAIVaultRate?: null,
      newVenusVAIVaultRate?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber],
      { oldVenusVAIVaultRate: BigNumber; newVenusVAIVaultRate: BigNumber }
    >;

    NewVenusVAIVaultRate(
      oldVenusVAIVaultRate?: null,
      newVenusVAIVaultRate?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber],
      { oldVenusVAIVaultRate: BigNumber; newVenusVAIVaultRate: BigNumber }
    >;

    "NewXVSToken(address,address)"(
      oldXVS?: string | null,
      newXVS?: string | null
    ): TypedEventFilter<[string, string], { oldXVS: string; newXVS: string }>;

    NewXVSToken(
      oldXVS?: string | null,
      newXVS?: string | null
    ): TypedEventFilter<[string, string], { oldXVS: string; newXVS: string }>;

    "NewXVSVToken(address,address)"(
      oldXVSVToken?: string | null,
      newXVSVToken?: string | null
    ): TypedEventFilter<
      [string, string],
      { oldXVSVToken: string; newXVSVToken: string }
    >;

    NewXVSVToken(
      oldXVSVToken?: string | null,
      newXVSVToken?: string | null
    ): TypedEventFilter<
      [string, string],
      { oldXVSVToken: string; newXVSVToken: string }
    >;

    "PoolActiveStatusUpdated(uint96,bool,bool)"(
      poolId?: BigNumberish | null,
      oldStatus?: null,
      newStatus?: null
    ): TypedEventFilter<
      [BigNumber, boolean, boolean],
      { poolId: BigNumber; oldStatus: boolean; newStatus: boolean }
    >;

    PoolActiveStatusUpdated(
      poolId?: BigNumberish | null,
      oldStatus?: null,
      newStatus?: null
    ): TypedEventFilter<
      [BigNumber, boolean, boolean],
      { poolId: BigNumber; oldStatus: boolean; newStatus: boolean }
    >;

    "PoolFallbackStatusUpdated(uint96,bool,bool)"(
      poolId?: BigNumberish | null,
      oldStatus?: null,
      newStatus?: null
    ): TypedEventFilter<
      [BigNumber, boolean, boolean],
      { poolId: BigNumber; oldStatus: boolean; newStatus: boolean }
    >;

    PoolFallbackStatusUpdated(
      poolId?: BigNumberish | null,
      oldStatus?: null,
      newStatus?: null
    ): TypedEventFilter<
      [BigNumber, boolean, boolean],
      { poolId: BigNumber; oldStatus: boolean; newStatus: boolean }
    >;

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

    PoolLabelUpdated(
      poolId?: BigNumberish | null,
      oldLabel?: null,
      newLabel?: null
    ): TypedEventFilter<
      [BigNumber, string, string],
      { poolId: BigNumber; oldLabel: string; newLabel: string }
    >;
  };

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

    _setActionsPaused(
      markets_: string[],
      actions_: BigNumberish[],
      paused_: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

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

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

    _setProtocolPaused(
      state: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    _setTreasuryData(
      newTreasuryGuardian: string,
      newTreasuryAddress: string,
      newTreasuryPercent: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

    _setVAIVaultInfo(
      vault_: string,
      releaseStartBlock_: BigNumberish,
      minReleaseAmount_: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

    _setXVSVToken(
      xvsVToken_: 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>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    setActionsPaused(
      markets_: string[],
      actions_: BigNumberish[],
      paused_: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

    setFlashLoanPaused(
      paused: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

    "setLiquidationIncentive(uint96,address,uint256)"(
      poolId: BigNumberish,
      vToken: string,
      newLiquidationIncentiveMantissa: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

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

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

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

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

    treasuryPercent(overrides?: CallOverrides): 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: {
    _setAccessControl(
      newAccessControlAddress: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    _setActionsPaused(
      markets_: string[],
      actions_: BigNumberish[],
      paused_: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

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

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

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

    _setProtocolPaused(
      state: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    _setTreasuryData(
      newTreasuryGuardian: string,
      newTreasuryAddress: string,
      newTreasuryPercent: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

    _setVAIVaultInfo(
      vault_: string,
      releaseStartBlock_: BigNumberish,
      minReleaseAmount_: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

    _setXVSVToken(
      xvsVToken_: 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>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    setActionsPaused(
      markets_: string[],
      actions_: BigNumberish[],
      paused_: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

    setFlashLoanPaused(
      paused: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

    "setLiquidationIncentive(uint96,address,uint256)"(
      poolId: BigNumberish,
      vToken: string,
      newLiquidationIncentiveMantissa: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

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

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

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

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

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

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