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

import {
  ethers,
  EventFilter,
  Signer,
  BigNumber,
  BigNumberish,
  PopulatedTransaction,
} from "ethers";
import {
  Contract,
  ContractTransaction,
  Overrides,
  PayableOverrides,
  CallOverrides,
} from "@ethersproject/contracts";
import { BytesLike } from "@ethersproject/bytes";
import { Listener, Provider } from "@ethersproject/providers";
import { FunctionFragment, EventFragment, Result } from "@ethersproject/abi";

interface GoldVeinPairMediumRiskV1Interface extends ethers.utils.Interface {
  functions: {
    "DOMAIN_SEPARATOR()": FunctionFragment;
    "accrue()": FunctionFragment;
    "accrueInfo()": FunctionFragment;
    "addAsset(address,bool,uint256)": FunctionFragment;
    "addCollateral(address,bool,uint256)": FunctionFragment;
    "alPine()": FunctionFragment;
    "allowance(address,address)": FunctionFragment;
    "approve(address,uint256)": FunctionFragment;
    "asset()": FunctionFragment;
    "balanceOf(address)": FunctionFragment;
    "borrow(address,uint256)": FunctionFragment;
    "claimOwnership()": FunctionFragment;
    "collateral()": FunctionFragment;
    "cook(uint8[],uint256[],bytes[])": FunctionFragment;
    "decimals()": FunctionFragment;
    "exchangeRate()": FunctionFragment;
    "feeTo()": FunctionFragment;
    "init(bytes)": FunctionFragment;
    "liquidate(address[],uint256[],address,address,bool)": FunctionFragment;
    "masterContract()": FunctionFragment;
    "name()": FunctionFragment;
    "nonces(address)": FunctionFragment;
    "oracle()": FunctionFragment;
    "oracleData()": FunctionFragment;
    "owner()": FunctionFragment;
    "pendingOwner()": FunctionFragment;
    "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)": FunctionFragment;
    "removeAsset(address,uint256)": FunctionFragment;
    "removeCollateral(address,uint256)": FunctionFragment;
    "repay(address,bool,uint256)": FunctionFragment;
    "setFeeTo(address)": FunctionFragment;
    "setSwapper(address,bool)": FunctionFragment;
    "swappers(address)": FunctionFragment;
    "symbol()": FunctionFragment;
    "totalAsset()": FunctionFragment;
    "totalBorrow()": FunctionFragment;
    "totalCollateralShare()": FunctionFragment;
    "totalSupply()": FunctionFragment;
    "transfer(address,uint256)": FunctionFragment;
    "transferFrom(address,address,uint256)": FunctionFragment;
    "transferOwnership(address,bool,bool)": FunctionFragment;
    "updateExchangeRate()": FunctionFragment;
    "userBorrowPart(address)": FunctionFragment;
    "userCollateralShare(address)": FunctionFragment;
    "withdrawFees()": FunctionFragment;
  };

  encodeFunctionData(
    functionFragment: "DOMAIN_SEPARATOR",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "accrue", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "accrueInfo",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "addAsset",
    values: [string, boolean, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "addCollateral",
    values: [string, boolean, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "alPine", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "allowance",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "approve",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "asset", values?: undefined): string;
  encodeFunctionData(functionFragment: "balanceOf", values: [string]): string;
  encodeFunctionData(
    functionFragment: "borrow",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "claimOwnership",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "collateral",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "cook",
    values: [BigNumberish[], BigNumberish[], BytesLike[]]
  ): string;
  encodeFunctionData(functionFragment: "decimals", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "exchangeRate",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "feeTo", values?: undefined): string;
  encodeFunctionData(functionFragment: "init", values: [BytesLike]): string;
  encodeFunctionData(
    functionFragment: "liquidate",
    values: [string[], BigNumberish[], string, string, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "masterContract",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "name", values?: undefined): string;
  encodeFunctionData(functionFragment: "nonces", values: [string]): string;
  encodeFunctionData(functionFragment: "oracle", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "oracleData",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "pendingOwner",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "permit",
    values: [
      string,
      string,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BytesLike,
      BytesLike
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "removeAsset",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "removeCollateral",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "repay",
    values: [string, boolean, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "setFeeTo", values: [string]): string;
  encodeFunctionData(
    functionFragment: "setSwapper",
    values: [string, boolean]
  ): string;
  encodeFunctionData(functionFragment: "swappers", values: [string]): string;
  encodeFunctionData(functionFragment: "symbol", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "totalAsset",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "totalBorrow",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "totalCollateralShare",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "totalSupply",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "transfer",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "transferFrom",
    values: [string, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "transferOwnership",
    values: [string, boolean, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "updateExchangeRate",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "userBorrowPart",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "userCollateralShare",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "withdrawFees",
    values?: undefined
  ): string;

  decodeFunctionResult(
    functionFragment: "DOMAIN_SEPARATOR",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "accrue", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "accrueInfo", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "addAsset", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "addCollateral",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "alPine", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "asset", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "borrow", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "claimOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "collateral", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "cook", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "exchangeRate",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "feeTo", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "init", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "liquidate", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "masterContract",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "nonces", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "oracle", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "oracleData", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "pendingOwner",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "permit", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "removeAsset",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "removeCollateral",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "repay", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "setFeeTo", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "setSwapper", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "swappers", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "totalAsset", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "totalBorrow",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "totalCollateralShare",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "totalSupply",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "transferFrom",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "transferOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateExchangeRate",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "userBorrowPart",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "userCollateralShare",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "withdrawFees",
    data: BytesLike
  ): Result;

  events: {
    "Approval(address,address,uint256)": EventFragment;
    "LogAccrue(uint256,uint256,uint64,uint256)": EventFragment;
    "LogAddAsset(address,address,uint256,uint256)": EventFragment;
    "LogAddCollateral(address,address,uint256)": EventFragment;
    "LogBorrow(address,address,uint256,uint256,uint256)": EventFragment;
    "LogExchangeRate(uint256)": EventFragment;
    "LogFeeTo(address)": EventFragment;
    "LogRemoveAsset(address,address,uint256,uint256)": EventFragment;
    "LogRemoveCollateral(address,address,uint256)": EventFragment;
    "LogRepay(address,address,uint256,uint256)": EventFragment;
    "LogWithdrawFees(address,uint256)": EventFragment;
    "OwnershipTransferred(address,address)": EventFragment;
    "Transfer(address,address,uint256)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogAccrue"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogAddAsset"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogAddCollateral"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogBorrow"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogExchangeRate"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogFeeTo"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogRemoveAsset"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogRemoveCollateral"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogRepay"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogWithdrawFees"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment;
}

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

  on(event: EventFilter | string, listener: Listener): this;
  once(event: EventFilter | string, listener: Listener): this;
  addListener(eventName: EventFilter | string, listener: Listener): this;
  removeAllListeners(eventName: EventFilter | string): this;
  removeListener(eventName: any, listener: Listener): this;

  interface: GoldVeinPairMediumRiskV1Interface;

  functions: {
    DOMAIN_SEPARATOR(overrides?: CallOverrides): Promise<[string]>;

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

    accrue(overrides?: Overrides): Promise<ContractTransaction>;

    "accrue()"(overrides?: Overrides): Promise<ContractTransaction>;

    accrueInfo(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber] & {
        interestPerSecond: BigNumber;
        lastAccrued: BigNumber;
        feesEarnedFraction: BigNumber;
      }
    >;

    "accrueInfo()"(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber] & {
        interestPerSecond: BigNumber;
        lastAccrued: BigNumber;
        feesEarnedFraction: BigNumber;
      }
    >;

    addAsset(
      to: string,
      skim: boolean,
      share: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "addAsset(address,bool,uint256)"(
      to: string,
      skim: boolean,
      share: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    addCollateral(
      to: string,
      skim: boolean,
      share: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "addCollateral(address,bool,uint256)"(
      to: string,
      skim: boolean,
      share: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

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

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

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

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

    approve(
      spender: string,
      amount: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "approve(address,uint256)"(
      spender: string,
      amount: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

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

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

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

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

    borrow(
      to: string,
      amount: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "borrow(address,uint256)"(
      to: string,
      amount: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    claimOwnership(overrides?: Overrides): Promise<ContractTransaction>;

    "claimOwnership()"(overrides?: Overrides): Promise<ContractTransaction>;

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

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

    cook(
      actions: BigNumberish[],
      values: BigNumberish[],
      datas: BytesLike[],
      overrides?: PayableOverrides
    ): Promise<ContractTransaction>;

    "cook(uint8[],uint256[],bytes[])"(
      actions: BigNumberish[],
      values: BigNumberish[],
      datas: BytesLike[],
      overrides?: PayableOverrides
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

    init(
      data: BytesLike,
      overrides?: PayableOverrides
    ): Promise<ContractTransaction>;

    "init(bytes)"(
      data: BytesLike,
      overrides?: PayableOverrides
    ): Promise<ContractTransaction>;

    liquidate(
      users: string[],
      maxBorrowParts: BigNumberish[],
      to: string,
      swapper: string,
      open: boolean,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "liquidate(address[],uint256[],address,address,bool)"(
      users: string[],
      maxBorrowParts: BigNumberish[],
      to: string,
      swapper: string,
      open: boolean,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    permit(
      owner_: string,
      spender: string,
      value: BigNumberish,
      deadline: BigNumberish,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)"(
      owner_: string,
      spender: string,
      value: BigNumberish,
      deadline: BigNumberish,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    removeAsset(
      to: string,
      fraction: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "removeAsset(address,uint256)"(
      to: string,
      fraction: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    removeCollateral(
      to: string,
      share: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "removeCollateral(address,uint256)"(
      to: string,
      share: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    repay(
      to: string,
      skim: boolean,
      part: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "repay(address,bool,uint256)"(
      to: string,
      skim: boolean,
      part: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    setFeeTo(
      newFeeTo: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "setFeeTo(address)"(
      newFeeTo: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    setSwapper(
      swapper: string,
      enable: boolean,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "setSwapper(address,bool)"(
      swapper: string,
      enable: boolean,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

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

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

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

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

    totalAsset(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & { elastic: BigNumber; base: BigNumber }
    >;

    "totalAsset()"(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & { elastic: BigNumber; base: BigNumber }
    >;

    totalBorrow(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & { elastic: BigNumber; base: BigNumber }
    >;

    "totalBorrow()"(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & { elastic: BigNumber; base: BigNumber }
    >;

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

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

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

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

    transfer(
      to: string,
      amount: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "transfer(address,uint256)"(
      to: string,
      amount: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    transferFrom(
      from: string,
      to: string,
      amount: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "transferFrom(address,address,uint256)"(
      from: string,
      to: string,
      amount: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    transferOwnership(
      newOwner: string,
      direct: boolean,
      renounce: boolean,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "transferOwnership(address,bool,bool)"(
      newOwner: string,
      direct: boolean,
      renounce: boolean,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    updateExchangeRate(overrides?: Overrides): Promise<ContractTransaction>;

    "updateExchangeRate()"(overrides?: Overrides): Promise<ContractTransaction>;

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

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

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

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

    withdrawFees(overrides?: Overrides): Promise<ContractTransaction>;

    "withdrawFees()"(overrides?: Overrides): Promise<ContractTransaction>;
  };

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

  "DOMAIN_SEPARATOR()"(overrides?: CallOverrides): Promise<string>;

  accrue(overrides?: Overrides): Promise<ContractTransaction>;

  "accrue()"(overrides?: Overrides): Promise<ContractTransaction>;

  accrueInfo(
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber, BigNumber] & {
      interestPerSecond: BigNumber;
      lastAccrued: BigNumber;
      feesEarnedFraction: BigNumber;
    }
  >;

  "accrueInfo()"(
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber, BigNumber] & {
      interestPerSecond: BigNumber;
      lastAccrued: BigNumber;
      feesEarnedFraction: BigNumber;
    }
  >;

  addAsset(
    to: string,
    skim: boolean,
    share: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "addAsset(address,bool,uint256)"(
    to: string,
    skim: boolean,
    share: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  addCollateral(
    to: string,
    skim: boolean,
    share: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "addCollateral(address,bool,uint256)"(
    to: string,
    skim: boolean,
    share: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

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

  "alPine()"(overrides?: CallOverrides): Promise<string>;

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

  "allowance(address,address)"(
    arg0: string,
    arg1: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  approve(
    spender: string,
    amount: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "approve(address,uint256)"(
    spender: string,
    amount: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

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

  "asset()"(overrides?: CallOverrides): Promise<string>;

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

  "balanceOf(address)"(
    arg0: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  borrow(
    to: string,
    amount: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "borrow(address,uint256)"(
    to: string,
    amount: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  claimOwnership(overrides?: Overrides): Promise<ContractTransaction>;

  "claimOwnership()"(overrides?: Overrides): Promise<ContractTransaction>;

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

  "collateral()"(overrides?: CallOverrides): Promise<string>;

  cook(
    actions: BigNumberish[],
    values: BigNumberish[],
    datas: BytesLike[],
    overrides?: PayableOverrides
  ): Promise<ContractTransaction>;

  "cook(uint8[],uint256[],bytes[])"(
    actions: BigNumberish[],
    values: BigNumberish[],
    datas: BytesLike[],
    overrides?: PayableOverrides
  ): Promise<ContractTransaction>;

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

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

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

  "exchangeRate()"(overrides?: CallOverrides): Promise<BigNumber>;

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

  "feeTo()"(overrides?: CallOverrides): Promise<string>;

  init(
    data: BytesLike,
    overrides?: PayableOverrides
  ): Promise<ContractTransaction>;

  "init(bytes)"(
    data: BytesLike,
    overrides?: PayableOverrides
  ): Promise<ContractTransaction>;

  liquidate(
    users: string[],
    maxBorrowParts: BigNumberish[],
    to: string,
    swapper: string,
    open: boolean,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "liquidate(address[],uint256[],address,address,bool)"(
    users: string[],
    maxBorrowParts: BigNumberish[],
    to: string,
    swapper: string,
    open: boolean,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

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

  "masterContract()"(overrides?: CallOverrides): Promise<string>;

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

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

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

  "nonces(address)"(
    arg0: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

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

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

  "oracleData()"(overrides?: CallOverrides): Promise<string>;

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

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

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

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

  permit(
    owner_: string,
    spender: string,
    value: BigNumberish,
    deadline: BigNumberish,
    v: BigNumberish,
    r: BytesLike,
    s: BytesLike,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)"(
    owner_: string,
    spender: string,
    value: BigNumberish,
    deadline: BigNumberish,
    v: BigNumberish,
    r: BytesLike,
    s: BytesLike,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  removeAsset(
    to: string,
    fraction: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "removeAsset(address,uint256)"(
    to: string,
    fraction: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  removeCollateral(
    to: string,
    share: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "removeCollateral(address,uint256)"(
    to: string,
    share: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  repay(
    to: string,
    skim: boolean,
    part: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "repay(address,bool,uint256)"(
    to: string,
    skim: boolean,
    part: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  setFeeTo(
    newFeeTo: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "setFeeTo(address)"(
    newFeeTo: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  setSwapper(
    swapper: string,
    enable: boolean,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "setSwapper(address,bool)"(
    swapper: string,
    enable: boolean,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

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

  "swappers(address)"(
    arg0: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

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

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

  totalAsset(
    overrides?: CallOverrides
  ): Promise<[BigNumber, BigNumber] & { elastic: BigNumber; base: BigNumber }>;

  "totalAsset()"(
    overrides?: CallOverrides
  ): Promise<[BigNumber, BigNumber] & { elastic: BigNumber; base: BigNumber }>;

  totalBorrow(
    overrides?: CallOverrides
  ): Promise<[BigNumber, BigNumber] & { elastic: BigNumber; base: BigNumber }>;

  "totalBorrow()"(
    overrides?: CallOverrides
  ): Promise<[BigNumber, BigNumber] & { elastic: BigNumber; base: BigNumber }>;

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

  "totalCollateralShare()"(overrides?: CallOverrides): Promise<BigNumber>;

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

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

  transfer(
    to: string,
    amount: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "transfer(address,uint256)"(
    to: string,
    amount: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  transferFrom(
    from: string,
    to: string,
    amount: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "transferFrom(address,address,uint256)"(
    from: string,
    to: string,
    amount: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  transferOwnership(
    newOwner: string,
    direct: boolean,
    renounce: boolean,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "transferOwnership(address,bool,bool)"(
    newOwner: string,
    direct: boolean,
    renounce: boolean,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  updateExchangeRate(overrides?: Overrides): Promise<ContractTransaction>;

  "updateExchangeRate()"(overrides?: Overrides): Promise<ContractTransaction>;

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

  "userBorrowPart(address)"(
    arg0: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

  "userCollateralShare(address)"(
    arg0: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  withdrawFees(overrides?: Overrides): Promise<ContractTransaction>;

  "withdrawFees()"(overrides?: Overrides): Promise<ContractTransaction>;

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

    "DOMAIN_SEPARATOR()"(overrides?: CallOverrides): Promise<string>;

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

    "accrue()"(overrides?: CallOverrides): Promise<void>;

    accrueInfo(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber] & {
        interestPerSecond: BigNumber;
        lastAccrued: BigNumber;
        feesEarnedFraction: BigNumber;
      }
    >;

    "accrueInfo()"(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber] & {
        interestPerSecond: BigNumber;
        lastAccrued: BigNumber;
        feesEarnedFraction: BigNumber;
      }
    >;

    addAsset(
      to: string,
      skim: boolean,
      share: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "addAsset(address,bool,uint256)"(
      to: string,
      skim: boolean,
      share: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    addCollateral(
      to: string,
      skim: boolean,
      share: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "addCollateral(address,bool,uint256)"(
      to: string,
      skim: boolean,
      share: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

    "alPine()"(overrides?: CallOverrides): Promise<string>;

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

    "allowance(address,address)"(
      arg0: string,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

    "asset()"(overrides?: CallOverrides): Promise<string>;

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

    "balanceOf(address)"(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    borrow(
      to: string,
      amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber, BigNumber] & { part: BigNumber; share: BigNumber }>;

    "borrow(address,uint256)"(
      to: string,
      amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber, BigNumber] & { part: BigNumber; share: BigNumber }>;

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

    "claimOwnership()"(overrides?: CallOverrides): Promise<void>;

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

    "collateral()"(overrides?: CallOverrides): Promise<string>;

    cook(
      actions: BigNumberish[],
      values: BigNumberish[],
      datas: BytesLike[],
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & { value1: BigNumber; value2: BigNumber }
    >;

    "cook(uint8[],uint256[],bytes[])"(
      actions: BigNumberish[],
      values: BigNumberish[],
      datas: BytesLike[],
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & { value1: BigNumber; value2: BigNumber }
    >;

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

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

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

    "exchangeRate()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "feeTo()"(overrides?: CallOverrides): Promise<string>;

    init(data: BytesLike, overrides?: CallOverrides): Promise<void>;

    "init(bytes)"(data: BytesLike, overrides?: CallOverrides): Promise<void>;

    liquidate(
      users: string[],
      maxBorrowParts: BigNumberish[],
      to: string,
      swapper: string,
      open: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

    "liquidate(address[],uint256[],address,address,bool)"(
      users: string[],
      maxBorrowParts: BigNumberish[],
      to: string,
      swapper: string,
      open: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

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

    "masterContract()"(overrides?: CallOverrides): Promise<string>;

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

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

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

    "nonces(address)"(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

    "oracleData()"(overrides?: CallOverrides): Promise<string>;

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

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

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

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

    permit(
      owner_: string,
      spender: string,
      value: BigNumberish,
      deadline: BigNumberish,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

    "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)"(
      owner_: string,
      spender: string,
      value: BigNumberish,
      deadline: BigNumberish,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

    removeAsset(
      to: string,
      fraction: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "removeAsset(address,uint256)"(
      to: string,
      fraction: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    removeCollateral(
      to: string,
      share: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "removeCollateral(address,uint256)"(
      to: string,
      share: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    repay(
      to: string,
      skim: boolean,
      part: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "repay(address,bool,uint256)"(
      to: string,
      skim: boolean,
      part: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    setFeeTo(newFeeTo: string, overrides?: CallOverrides): Promise<void>;

    "setFeeTo(address)"(
      newFeeTo: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setSwapper(
      swapper: string,
      enable: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

    "setSwapper(address,bool)"(
      swapper: string,
      enable: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

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

    "swappers(address)"(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

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

    totalAsset(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & { elastic: BigNumber; base: BigNumber }
    >;

    "totalAsset()"(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & { elastic: BigNumber; base: BigNumber }
    >;

    totalBorrow(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & { elastic: BigNumber; base: BigNumber }
    >;

    "totalBorrow()"(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & { elastic: BigNumber; base: BigNumber }
    >;

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

    "totalCollateralShare()"(overrides?: CallOverrides): Promise<BigNumber>;

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

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

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

    "transfer(address,uint256)"(
      to: string,
      amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

    "transferFrom(address,address,uint256)"(
      from: string,
      to: string,
      amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

    "transferOwnership(address,bool,bool)"(
      newOwner: string,
      direct: boolean,
      renounce: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

    updateExchangeRate(
      overrides?: CallOverrides
    ): Promise<[boolean, BigNumber] & { updated: boolean; rate: BigNumber }>;

    "updateExchangeRate()"(
      overrides?: CallOverrides
    ): Promise<[boolean, BigNumber] & { updated: boolean; rate: BigNumber }>;

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

    "userBorrowPart(address)"(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    "userCollateralShare(address)"(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    "withdrawFees()"(overrides?: CallOverrides): Promise<void>;
  };

  filters: {
    Approval(
      _owner: string | null,
      _spender: string | null,
      _value: null
    ): EventFilter;

    LogAccrue(
      accruedAmount: null,
      feeFraction: null,
      rate: null,
      utilization: null
    ): EventFilter;

    LogAddAsset(
      from: string | null,
      to: string | null,
      share: null,
      fraction: null
    ): EventFilter;

    LogAddCollateral(
      from: string | null,
      to: string | null,
      share: null
    ): EventFilter;

    LogBorrow(
      from: string | null,
      to: string | null,
      amount: null,
      feeAmount: null,
      part: null
    ): EventFilter;

    LogExchangeRate(rate: null): EventFilter;

    LogFeeTo(newFeeTo: string | null): EventFilter;

    LogRemoveAsset(
      from: string | null,
      to: string | null,
      share: null,
      fraction: null
    ): EventFilter;

    LogRemoveCollateral(
      from: string | null,
      to: string | null,
      share: null
    ): EventFilter;

    LogRepay(
      from: string | null,
      to: string | null,
      amount: null,
      part: null
    ): EventFilter;

    LogWithdrawFees(
      feeTo: string | null,
      feesEarnedFraction: null
    ): EventFilter;

    OwnershipTransferred(
      previousOwner: string | null,
      newOwner: string | null
    ): EventFilter;

    Transfer(
      _from: string | null,
      _to: string | null,
      _value: null
    ): EventFilter;
  };

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

    "DOMAIN_SEPARATOR()"(overrides?: CallOverrides): Promise<BigNumber>;

    accrue(overrides?: Overrides): Promise<BigNumber>;

    "accrue()"(overrides?: Overrides): Promise<BigNumber>;

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

    "accrueInfo()"(overrides?: CallOverrides): Promise<BigNumber>;

    addAsset(
      to: string,
      skim: boolean,
      share: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "addAsset(address,bool,uint256)"(
      to: string,
      skim: boolean,
      share: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    addCollateral(
      to: string,
      skim: boolean,
      share: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "addCollateral(address,bool,uint256)"(
      to: string,
      skim: boolean,
      share: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

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

    "alPine()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "allowance(address,address)"(
      arg0: string,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    approve(
      spender: string,
      amount: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "approve(address,uint256)"(
      spender: string,
      amount: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

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

    "asset()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "balanceOf(address)"(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    borrow(
      to: string,
      amount: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "borrow(address,uint256)"(
      to: string,
      amount: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    claimOwnership(overrides?: Overrides): Promise<BigNumber>;

    "claimOwnership()"(overrides?: Overrides): Promise<BigNumber>;

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

    "collateral()"(overrides?: CallOverrides): Promise<BigNumber>;

    cook(
      actions: BigNumberish[],
      values: BigNumberish[],
      datas: BytesLike[],
      overrides?: PayableOverrides
    ): Promise<BigNumber>;

    "cook(uint8[],uint256[],bytes[])"(
      actions: BigNumberish[],
      values: BigNumberish[],
      datas: BytesLike[],
      overrides?: PayableOverrides
    ): Promise<BigNumber>;

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

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

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

    "exchangeRate()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "feeTo()"(overrides?: CallOverrides): Promise<BigNumber>;

    init(data: BytesLike, overrides?: PayableOverrides): Promise<BigNumber>;

    "init(bytes)"(
      data: BytesLike,
      overrides?: PayableOverrides
    ): Promise<BigNumber>;

    liquidate(
      users: string[],
      maxBorrowParts: BigNumberish[],
      to: string,
      swapper: string,
      open: boolean,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "liquidate(address[],uint256[],address,address,bool)"(
      users: string[],
      maxBorrowParts: BigNumberish[],
      to: string,
      swapper: string,
      open: boolean,
      overrides?: Overrides
    ): Promise<BigNumber>;

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

    "masterContract()"(overrides?: CallOverrides): Promise<BigNumber>;

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

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

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

    "nonces(address)"(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

    "oracleData()"(overrides?: CallOverrides): Promise<BigNumber>;

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

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

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

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

    permit(
      owner_: string,
      spender: string,
      value: BigNumberish,
      deadline: BigNumberish,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)"(
      owner_: string,
      spender: string,
      value: BigNumberish,
      deadline: BigNumberish,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: Overrides
    ): Promise<BigNumber>;

    removeAsset(
      to: string,
      fraction: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "removeAsset(address,uint256)"(
      to: string,
      fraction: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    removeCollateral(
      to: string,
      share: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "removeCollateral(address,uint256)"(
      to: string,
      share: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    repay(
      to: string,
      skim: boolean,
      part: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "repay(address,bool,uint256)"(
      to: string,
      skim: boolean,
      part: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    setFeeTo(newFeeTo: string, overrides?: Overrides): Promise<BigNumber>;

    "setFeeTo(address)"(
      newFeeTo: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    setSwapper(
      swapper: string,
      enable: boolean,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "setSwapper(address,bool)"(
      swapper: string,
      enable: boolean,
      overrides?: Overrides
    ): Promise<BigNumber>;

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

    "swappers(address)"(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

    "totalAsset()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "totalBorrow()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "totalCollateralShare()"(overrides?: CallOverrides): Promise<BigNumber>;

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

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

    transfer(
      to: string,
      amount: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "transfer(address,uint256)"(
      to: string,
      amount: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    transferFrom(
      from: string,
      to: string,
      amount: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "transferFrom(address,address,uint256)"(
      from: string,
      to: string,
      amount: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    transferOwnership(
      newOwner: string,
      direct: boolean,
      renounce: boolean,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "transferOwnership(address,bool,bool)"(
      newOwner: string,
      direct: boolean,
      renounce: boolean,
      overrides?: Overrides
    ): Promise<BigNumber>;

    updateExchangeRate(overrides?: Overrides): Promise<BigNumber>;

    "updateExchangeRate()"(overrides?: Overrides): Promise<BigNumber>;

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

    "userBorrowPart(address)"(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    "userCollateralShare(address)"(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    withdrawFees(overrides?: Overrides): Promise<BigNumber>;

    "withdrawFees()"(overrides?: Overrides): Promise<BigNumber>;
  };

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

    "DOMAIN_SEPARATOR()"(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    accrue(overrides?: Overrides): Promise<PopulatedTransaction>;

    "accrue()"(overrides?: Overrides): Promise<PopulatedTransaction>;

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

    "accrueInfo()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    addAsset(
      to: string,
      skim: boolean,
      share: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "addAsset(address,bool,uint256)"(
      to: string,
      skim: boolean,
      share: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    addCollateral(
      to: string,
      skim: boolean,
      share: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "addCollateral(address,bool,uint256)"(
      to: string,
      skim: boolean,
      share: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

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

    "alPine()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

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

    "allowance(address,address)"(
      arg0: string,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    approve(
      spender: string,
      amount: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "approve(address,uint256)"(
      spender: string,
      amount: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

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

    "asset()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

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

    "balanceOf(address)"(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    borrow(
      to: string,
      amount: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "borrow(address,uint256)"(
      to: string,
      amount: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    claimOwnership(overrides?: Overrides): Promise<PopulatedTransaction>;

    "claimOwnership()"(overrides?: Overrides): Promise<PopulatedTransaction>;

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

    "collateral()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    cook(
      actions: BigNumberish[],
      values: BigNumberish[],
      datas: BytesLike[],
      overrides?: PayableOverrides
    ): Promise<PopulatedTransaction>;

    "cook(uint8[],uint256[],bytes[])"(
      actions: BigNumberish[],
      values: BigNumberish[],
      datas: BytesLike[],
      overrides?: PayableOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

    "exchangeRate()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

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

    "feeTo()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    init(
      data: BytesLike,
      overrides?: PayableOverrides
    ): Promise<PopulatedTransaction>;

    "init(bytes)"(
      data: BytesLike,
      overrides?: PayableOverrides
    ): Promise<PopulatedTransaction>;

    liquidate(
      users: string[],
      maxBorrowParts: BigNumberish[],
      to: string,
      swapper: string,
      open: boolean,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "liquidate(address[],uint256[],address,address,bool)"(
      users: string[],
      maxBorrowParts: BigNumberish[],
      to: string,
      swapper: string,
      open: boolean,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

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

    "masterContract()"(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

    "nonces(address)"(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

    "oracleData()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

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

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

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

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

    permit(
      owner_: string,
      spender: string,
      value: BigNumberish,
      deadline: BigNumberish,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)"(
      owner_: string,
      spender: string,
      value: BigNumberish,
      deadline: BigNumberish,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    removeAsset(
      to: string,
      fraction: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "removeAsset(address,uint256)"(
      to: string,
      fraction: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    removeCollateral(
      to: string,
      share: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "removeCollateral(address,uint256)"(
      to: string,
      share: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    repay(
      to: string,
      skim: boolean,
      part: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "repay(address,bool,uint256)"(
      to: string,
      skim: boolean,
      part: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    setFeeTo(
      newFeeTo: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "setFeeTo(address)"(
      newFeeTo: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    setSwapper(
      swapper: string,
      enable: boolean,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "setSwapper(address,bool)"(
      swapper: string,
      enable: boolean,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

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

    "swappers(address)"(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

    "totalAsset()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

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

    "totalBorrow()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

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

    "totalCollateralShare()"(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    transfer(
      to: string,
      amount: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "transfer(address,uint256)"(
      to: string,
      amount: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    transferFrom(
      from: string,
      to: string,
      amount: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "transferFrom(address,address,uint256)"(
      from: string,
      to: string,
      amount: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    transferOwnership(
      newOwner: string,
      direct: boolean,
      renounce: boolean,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "transferOwnership(address,bool,bool)"(
      newOwner: string,
      direct: boolean,
      renounce: boolean,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    updateExchangeRate(overrides?: Overrides): Promise<PopulatedTransaction>;

    "updateExchangeRate()"(
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

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

    "userBorrowPart(address)"(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    "userCollateralShare(address)"(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    withdrawFees(overrides?: Overrides): Promise<PopulatedTransaction>;

    "withdrawFees()"(overrides?: Overrides): Promise<PopulatedTransaction>;
  };
}