/* 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 ZapInterface extends ethers.utils.Interface {
  functions: {
    "DAI()": FunctionFragment;
    "JOE()": FunctionFragment;
    "USDT()": FunctionFragment;
    "WAVAX()": FunctionFragment;
    "initialize(address,address)": FunctionFragment;
    "isLP(address)": FunctionFragment;
    "owner()": FunctionFragment;
    "removeToken(uint256)": FunctionFragment;
    "renounceOwnership()": FunctionFragment;
    "routePair(address)": FunctionFragment;
    "setNotLP(address)": FunctionFragment;
    "setRoutePairAddress(address,address)": FunctionFragment;
    "sweep()": FunctionFragment;
    "tokens(uint256)": FunctionFragment;
    "transferOwnership(address)": FunctionFragment;
    "withdraw(address)": FunctionFragment;
    "zapIn(address)": FunctionFragment;
    "zapInToken(address,uint256,address)": FunctionFragment;
    "zapOut(address,uint256)": FunctionFragment;
  };

  encodeFunctionData(functionFragment: "DAI", values?: undefined): string;
  encodeFunctionData(functionFragment: "JOE", values?: undefined): string;
  encodeFunctionData(functionFragment: "USDT", values?: undefined): string;
  encodeFunctionData(functionFragment: "WAVAX", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "initialize",
    values: [string, string]
  ): string;
  encodeFunctionData(functionFragment: "isLP", values: [string]): string;
  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "removeToken",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "renounceOwnership",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "routePair", values: [string]): string;
  encodeFunctionData(functionFragment: "setNotLP", values: [string]): string;
  encodeFunctionData(
    functionFragment: "setRoutePairAddress",
    values: [string, string]
  ): string;
  encodeFunctionData(functionFragment: "sweep", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "tokens",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "transferOwnership",
    values: [string]
  ): string;
  encodeFunctionData(functionFragment: "withdraw", values: [string]): string;
  encodeFunctionData(functionFragment: "zapIn", values: [string]): string;
  encodeFunctionData(
    functionFragment: "zapInToken",
    values: [string, BigNumberish, string]
  ): string;
  encodeFunctionData(
    functionFragment: "zapOut",
    values: [string, BigNumberish]
  ): string;

  decodeFunctionResult(functionFragment: "DAI", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "JOE", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "USDT", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "WAVAX", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "isLP", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "removeToken",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "renounceOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "routePair", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "setNotLP", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setRoutePairAddress",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "sweep", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "tokens", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "transferOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "zapIn", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "zapInToken", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "zapOut", data: BytesLike): Result;

  events: {
    "OwnershipTransferred(address,address)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
}

export class Zap 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: ZapInterface;

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

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

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

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

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

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

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

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

    initialize(
      _joe: string,
      _router: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "initialize(address,address)"(
      _joe: string,
      _router: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    isLP(_address: string, overrides?: CallOverrides): Promise<[boolean]>;

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

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

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

    removeToken(
      i: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "removeToken(uint256)"(
      i: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

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

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

    routePair(_address: string, overrides?: CallOverrides): Promise<[string]>;

    "routePair(address)"(
      _address: string,
      overrides?: CallOverrides
    ): Promise<[string]>;

    setNotLP(
      token: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "setNotLP(address)"(
      token: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    setRoutePairAddress(
      asset: string,
      route: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "setRoutePairAddress(address,address)"(
      asset: string,
      route: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

    withdraw(
      token: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "withdraw(address)"(
      token: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    zapIn(
      _to: string,
      overrides?: PayableOverrides
    ): Promise<ContractTransaction>;

    "zapIn(address)"(
      _to: string,
      overrides?: PayableOverrides
    ): Promise<ContractTransaction>;

    zapInToken(
      _from: string,
      amount: BigNumberish,
      _to: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "zapInToken(address,uint256,address)"(
      _from: string,
      amount: BigNumberish,
      _to: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    zapOut(
      _from: string,
      amount: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "zapOut(address,uint256)"(
      _from: string,
      amount: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;
  };

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

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

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

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

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

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

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

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

  initialize(
    _joe: string,
    _router: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "initialize(address,address)"(
    _joe: string,
    _router: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  isLP(_address: string, overrides?: CallOverrides): Promise<boolean>;

  "isLP(address)"(
    _address: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

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

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

  removeToken(
    i: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "removeToken(uint256)"(
    i: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

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

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

  routePair(_address: string, overrides?: CallOverrides): Promise<string>;

  "routePair(address)"(
    _address: string,
    overrides?: CallOverrides
  ): Promise<string>;

  setNotLP(token: string, overrides?: Overrides): Promise<ContractTransaction>;

  "setNotLP(address)"(
    token: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  setRoutePairAddress(
    asset: string,
    route: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "setRoutePairAddress(address,address)"(
    asset: string,
    route: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

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

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

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

  "tokens(uint256)"(
    arg0: BigNumberish,
    overrides?: CallOverrides
  ): Promise<string>;

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

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

  withdraw(token: string, overrides?: Overrides): Promise<ContractTransaction>;

  "withdraw(address)"(
    token: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  zapIn(
    _to: string,
    overrides?: PayableOverrides
  ): Promise<ContractTransaction>;

  "zapIn(address)"(
    _to: string,
    overrides?: PayableOverrides
  ): Promise<ContractTransaction>;

  zapInToken(
    _from: string,
    amount: BigNumberish,
    _to: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "zapInToken(address,uint256,address)"(
    _from: string,
    amount: BigNumberish,
    _to: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  zapOut(
    _from: string,
    amount: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

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

    initialize(
      _joe: string,
      _router: string,
      overrides?: CallOverrides
    ): Promise<void>;

    "initialize(address,address)"(
      _joe: string,
      _router: string,
      overrides?: CallOverrides
    ): Promise<void>;

    isLP(_address: string, overrides?: CallOverrides): Promise<boolean>;

    "isLP(address)"(
      _address: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

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

    removeToken(i: BigNumberish, overrides?: CallOverrides): Promise<void>;

    "removeToken(uint256)"(
      i: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    routePair(_address: string, overrides?: CallOverrides): Promise<string>;

    "routePair(address)"(
      _address: string,
      overrides?: CallOverrides
    ): Promise<string>;

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

    "setNotLP(address)"(
      token: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setRoutePairAddress(
      asset: string,
      route: string,
      overrides?: CallOverrides
    ): Promise<void>;

    "setRoutePairAddress(address,address)"(
      asset: string,
      route: string,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

    "tokens(uint256)"(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string>;

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

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

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

    "withdraw(address)"(
      token: string,
      overrides?: CallOverrides
    ): Promise<void>;

    zapIn(_to: string, overrides?: CallOverrides): Promise<void>;

    "zapIn(address)"(_to: string, overrides?: CallOverrides): Promise<void>;

    zapInToken(
      _from: string,
      amount: BigNumberish,
      _to: string,
      overrides?: CallOverrides
    ): Promise<void>;

    "zapInToken(address,uint256,address)"(
      _from: string,
      amount: BigNumberish,
      _to: string,
      overrides?: CallOverrides
    ): Promise<void>;

    zapOut(
      _from: string,
      amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "zapOut(address,uint256)"(
      _from: string,
      amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;
  };

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

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

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

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

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

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

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

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

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

    initialize(
      _joe: string,
      _router: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "initialize(address,address)"(
      _joe: string,
      _router: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    isLP(_address: string, overrides?: CallOverrides): Promise<BigNumber>;

    "isLP(address)"(
      _address: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    removeToken(i: BigNumberish, overrides?: Overrides): Promise<BigNumber>;

    "removeToken(uint256)"(
      i: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

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

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

    routePair(_address: string, overrides?: CallOverrides): Promise<BigNumber>;

    "routePair(address)"(
      _address: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    setNotLP(token: string, overrides?: Overrides): Promise<BigNumber>;

    "setNotLP(address)"(
      token: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    setRoutePairAddress(
      asset: string,
      route: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "setRoutePairAddress(address,address)"(
      asset: string,
      route: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

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

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

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

    "tokens(uint256)"(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    withdraw(token: string, overrides?: Overrides): Promise<BigNumber>;

    "withdraw(address)"(
      token: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    zapIn(_to: string, overrides?: PayableOverrides): Promise<BigNumber>;

    "zapIn(address)"(
      _to: string,
      overrides?: PayableOverrides
    ): Promise<BigNumber>;

    zapInToken(
      _from: string,
      amount: BigNumberish,
      _to: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "zapInToken(address,uint256,address)"(
      _from: string,
      amount: BigNumberish,
      _to: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    zapOut(
      _from: string,
      amount: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "zapOut(address,uint256)"(
      _from: string,
      amount: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;
  };

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

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

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

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

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

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

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

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

    initialize(
      _joe: string,
      _router: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "initialize(address,address)"(
      _joe: string,
      _router: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    isLP(
      _address: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "isLP(address)"(
      _address: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    removeToken(
      i: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "removeToken(uint256)"(
      i: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

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

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

    routePair(
      _address: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "routePair(address)"(
      _address: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    setNotLP(
      token: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "setNotLP(address)"(
      token: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    setRoutePairAddress(
      asset: string,
      route: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "setRoutePairAddress(address,address)"(
      asset: string,
      route: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

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

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

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

    "tokens(uint256)"(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    withdraw(
      token: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "withdraw(address)"(
      token: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    zapIn(
      _to: string,
      overrides?: PayableOverrides
    ): Promise<PopulatedTransaction>;

    "zapIn(address)"(
      _to: string,
      overrides?: PayableOverrides
    ): Promise<PopulatedTransaction>;

    zapInToken(
      _from: string,
      amount: BigNumberish,
      _to: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "zapInToken(address,uint256,address)"(
      _from: string,
      amount: BigNumberish,
      _to: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    zapOut(
      _from: string,
      amount: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "zapOut(address,uint256)"(
      _from: string,
      amount: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;
  };
}