/* Autogenerated file. Do not edit manually. */
/* tslint:disable */
/* eslint-disable */
import {
  BaseContract,
  BigNumber,
  BigNumberish,
  BytesLike,
  CallOverrides,
  ContractTransaction,
  Overrides,
  PopulatedTransaction,
  Signer,
  utils,
} from "ethers";
import { FunctionFragment, Result } from "@ethersproject/abi";
import { Listener, Provider } from "@ethersproject/providers";
import { TypedEventFilter, TypedEvent, TypedListener, OnEvent } from "./common";

export interface TestUniswapInterface extends utils.Interface {
  contractName: "TestUniswap";
  functions: {
    "WETH()": FunctionFragment;
    "getAmountsIn(uint256,address[])": FunctionFragment;
    "getTokenToEthInputPrice(uint256)": FunctionFragment;
    "getTokenToEthOutputPrice(uint256)": FunctionFragment;
    "pu(address)": FunctionFragment;
    "rateDiv()": FunctionFragment;
    "rateMult()": FunctionFragment;
    "swapExactTokensForETH(uint256,uint256,address[],address,uint256)": FunctionFragment;
    "token(uint256)": FunctionFragment;
    "tokenAddress(uint256)": FunctionFragment;
    "tokenToEthSwapOutput(address,uint256,uint256,uint256)": FunctionFragment;
    "tokenToEthTransferOutput(address,uint256,uint256,uint256,address)": FunctionFragment;
  };

  encodeFunctionData(functionFragment: "WETH", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "getAmountsIn",
    values: [BigNumberish, string[]]
  ): string;
  encodeFunctionData(
    functionFragment: "getTokenToEthInputPrice",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getTokenToEthOutputPrice",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "pu", values: [string]): string;
  encodeFunctionData(functionFragment: "rateDiv", values?: undefined): string;
  encodeFunctionData(functionFragment: "rateMult", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "swapExactTokensForETH",
    values: [BigNumberish, BigNumberish, string[], string, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "token", values: [BigNumberish]): string;
  encodeFunctionData(
    functionFragment: "tokenAddress",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "tokenToEthSwapOutput",
    values: [string, BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "tokenToEthTransferOutput",
    values: [string, BigNumberish, BigNumberish, BigNumberish, string]
  ): string;

  decodeFunctionResult(functionFragment: "WETH", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getAmountsIn",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getTokenToEthInputPrice",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getTokenToEthOutputPrice",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "pu", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "rateDiv", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "rateMult", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "swapExactTokensForETH",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "token", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "tokenAddress",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "tokenToEthSwapOutput",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "tokenToEthTransferOutput",
    data: BytesLike
  ): Result;

  events: {};
}

export interface TestUniswap extends BaseContract {
  contractName: "TestUniswap";
  connect(signerOrProvider: Signer | Provider | string): this;
  attach(addressOrName: string): this;
  deployed(): Promise<this>;

  interface: TestUniswapInterface;

  queryFilter<TEvent extends TypedEvent>(
    event: TypedEventFilter<TEvent>,
    fromBlockOrBlockhash?: string | number | undefined,
    toBlock?: string | number | undefined
  ): Promise<Array<TEvent>>;

  listeners<TEvent extends TypedEvent>(
    eventFilter?: TypedEventFilter<TEvent>
  ): Array<TypedListener<TEvent>>;
  listeners(eventName?: string): Array<Listener>;
  removeAllListeners<TEvent extends TypedEvent>(
    eventFilter: TypedEventFilter<TEvent>
  ): this;
  removeAllListeners(eventName?: string): this;
  off: OnEvent<this>;
  on: OnEvent<this>;
  once: OnEvent<this>;
  removeListener: OnEvent<this>;

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

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

    getAmountsIn(
      amountOut: BigNumberish,
      path: string[],
      overrides?: CallOverrides
    ): Promise<[BigNumber[]] & { amounts: BigNumber[] }>;

    "getAmountsIn(uint256,address[])"(
      amountOut: BigNumberish,
      path: string[],
      overrides?: CallOverrides
    ): Promise<[BigNumber[]] & { amounts: BigNumber[] }>;

    getTokenToEthInputPrice(
      tokensSold: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { out: BigNumber }>;

    "getTokenToEthInputPrice(uint256)"(
      tokensSold: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { out: BigNumber }>;

    getTokenToEthOutputPrice(
      ethBought: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { out: BigNumber }>;

    "getTokenToEthOutputPrice(uint256)"(
      ethBought: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { out: BigNumber }>;

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

    "pu(address)"(
      _erc20: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

    swapExactTokensForETH(
      amountIn: BigNumberish,
      amountOutMin: BigNumberish,
      path: string[],
      to: string,
      deadline: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    "swapExactTokensForETH(uint256,uint256,address[],address,uint256)"(
      amountIn: BigNumberish,
      amountOutMin: BigNumberish,
      path: string[],
      to: string,
      deadline: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

    tokenAddress(
      i: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[string] & { out: string }>;

    "tokenAddress(uint256)"(
      i: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[string] & { out: string }>;

    tokenToEthSwapOutput(
      _token: string,
      ethBought: BigNumberish,
      maxTokens: BigNumberish,
      deadline: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    "tokenToEthSwapOutput(address,uint256,uint256,uint256)"(
      _token: string,
      ethBought: BigNumberish,
      maxTokens: BigNumberish,
      deadline: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    tokenToEthTransferOutput(
      _token: string,
      ethBought: BigNumberish,
      maxTokens: BigNumberish,
      deadline: BigNumberish,
      recipient: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    "tokenToEthTransferOutput(address,uint256,uint256,uint256,address)"(
      _token: string,
      ethBought: BigNumberish,
      maxTokens: BigNumberish,
      deadline: BigNumberish,
      recipient: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;
  };

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

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

  getAmountsIn(
    amountOut: BigNumberish,
    path: string[],
    overrides?: CallOverrides
  ): Promise<BigNumber[]>;

  "getAmountsIn(uint256,address[])"(
    amountOut: BigNumberish,
    path: string[],
    overrides?: CallOverrides
  ): Promise<BigNumber[]>;

  getTokenToEthInputPrice(
    tokensSold: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  "getTokenToEthInputPrice(uint256)"(
    tokensSold: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  getTokenToEthOutputPrice(
    ethBought: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  "getTokenToEthOutputPrice(uint256)"(
    ethBought: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

  "pu(address)"(
    _erc20: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

  swapExactTokensForETH(
    amountIn: BigNumberish,
    amountOutMin: BigNumberish,
    path: string[],
    to: string,
    deadline: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  "swapExactTokensForETH(uint256,uint256,address[],address,uint256)"(
    amountIn: BigNumberish,
    amountOutMin: BigNumberish,
    path: string[],
    to: string,
    deadline: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

  tokenAddress(i: BigNumberish, overrides?: CallOverrides): Promise<string>;

  "tokenAddress(uint256)"(
    i: BigNumberish,
    overrides?: CallOverrides
  ): Promise<string>;

  tokenToEthSwapOutput(
    _token: string,
    ethBought: BigNumberish,
    maxTokens: BigNumberish,
    deadline: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  "tokenToEthSwapOutput(address,uint256,uint256,uint256)"(
    _token: string,
    ethBought: BigNumberish,
    maxTokens: BigNumberish,
    deadline: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  tokenToEthTransferOutput(
    _token: string,
    ethBought: BigNumberish,
    maxTokens: BigNumberish,
    deadline: BigNumberish,
    recipient: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  "tokenToEthTransferOutput(address,uint256,uint256,uint256,address)"(
    _token: string,
    ethBought: BigNumberish,
    maxTokens: BigNumberish,
    deadline: BigNumberish,
    recipient: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

    getAmountsIn(
      amountOut: BigNumberish,
      path: string[],
      overrides?: CallOverrides
    ): Promise<BigNumber[]>;

    "getAmountsIn(uint256,address[])"(
      amountOut: BigNumberish,
      path: string[],
      overrides?: CallOverrides
    ): Promise<BigNumber[]>;

    getTokenToEthInputPrice(
      tokensSold: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getTokenToEthInputPrice(uint256)"(
      tokensSold: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getTokenToEthOutputPrice(
      ethBought: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getTokenToEthOutputPrice(uint256)"(
      ethBought: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    pu(_erc20: string, overrides?: CallOverrides): Promise<void>;

    "pu(address)"(_erc20: string, overrides?: CallOverrides): Promise<void>;

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

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

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

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

    swapExactTokensForETH(
      amountIn: BigNumberish,
      amountOutMin: BigNumberish,
      path: string[],
      to: string,
      deadline: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "swapExactTokensForETH(uint256,uint256,address[],address,uint256)"(
      amountIn: BigNumberish,
      amountOutMin: BigNumberish,
      path: string[],
      to: string,
      deadline: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    tokenAddress(i: BigNumberish, overrides?: CallOverrides): Promise<string>;

    "tokenAddress(uint256)"(
      i: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string>;

    tokenToEthSwapOutput(
      _token: string,
      ethBought: BigNumberish,
      maxTokens: BigNumberish,
      deadline: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "tokenToEthSwapOutput(address,uint256,uint256,uint256)"(
      _token: string,
      ethBought: BigNumberish,
      maxTokens: BigNumberish,
      deadline: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    tokenToEthTransferOutput(
      _token: string,
      ethBought: BigNumberish,
      maxTokens: BigNumberish,
      deadline: BigNumberish,
      recipient: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "tokenToEthTransferOutput(address,uint256,uint256,uint256,address)"(
      _token: string,
      ethBought: BigNumberish,
      maxTokens: BigNumberish,
      deadline: BigNumberish,
      recipient: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;
  };

  filters: {};

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

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

    getAmountsIn(
      amountOut: BigNumberish,
      path: string[],
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getAmountsIn(uint256,address[])"(
      amountOut: BigNumberish,
      path: string[],
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getTokenToEthInputPrice(
      tokensSold: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getTokenToEthInputPrice(uint256)"(
      tokensSold: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getTokenToEthOutputPrice(
      ethBought: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getTokenToEthOutputPrice(uint256)"(
      ethBought: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    "pu(address)"(
      _erc20: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

    swapExactTokensForETH(
      amountIn: BigNumberish,
      amountOutMin: BigNumberish,
      path: string[],
      to: string,
      deadline: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    "swapExactTokensForETH(uint256,uint256,address[],address,uint256)"(
      amountIn: BigNumberish,
      amountOutMin: BigNumberish,
      path: string[],
      to: string,
      deadline: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

    tokenAddress(
      i: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "tokenAddress(uint256)"(
      i: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    tokenToEthSwapOutput(
      _token: string,
      ethBought: BigNumberish,
      maxTokens: BigNumberish,
      deadline: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    "tokenToEthSwapOutput(address,uint256,uint256,uint256)"(
      _token: string,
      ethBought: BigNumberish,
      maxTokens: BigNumberish,
      deadline: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    tokenToEthTransferOutput(
      _token: string,
      ethBought: BigNumberish,
      maxTokens: BigNumberish,
      deadline: BigNumberish,
      recipient: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    "tokenToEthTransferOutput(address,uint256,uint256,uint256,address)"(
      _token: string,
      ethBought: BigNumberish,
      maxTokens: BigNumberish,
      deadline: BigNumberish,
      recipient: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;
  };

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

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

    getAmountsIn(
      amountOut: BigNumberish,
      path: string[],
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "getAmountsIn(uint256,address[])"(
      amountOut: BigNumberish,
      path: string[],
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getTokenToEthInputPrice(
      tokensSold: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "getTokenToEthInputPrice(uint256)"(
      tokensSold: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getTokenToEthOutputPrice(
      ethBought: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "getTokenToEthOutputPrice(uint256)"(
      ethBought: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    "pu(address)"(
      _erc20: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

    swapExactTokensForETH(
      amountIn: BigNumberish,
      amountOutMin: BigNumberish,
      path: string[],
      to: string,
      deadline: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    "swapExactTokensForETH(uint256,uint256,address[],address,uint256)"(
      amountIn: BigNumberish,
      amountOutMin: BigNumberish,
      path: string[],
      to: string,
      deadline: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

    tokenAddress(
      i: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "tokenAddress(uint256)"(
      i: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    tokenToEthSwapOutput(
      _token: string,
      ethBought: BigNumberish,
      maxTokens: BigNumberish,
      deadline: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    "tokenToEthSwapOutput(address,uint256,uint256,uint256)"(
      _token: string,
      ethBought: BigNumberish,
      maxTokens: BigNumberish,
      deadline: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    tokenToEthTransferOutput(
      _token: string,
      ethBought: BigNumberish,
      maxTokens: BigNumberish,
      deadline: BigNumberish,
      recipient: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    "tokenToEthTransferOutput(address,uint256,uint256,uint256,address)"(
      _token: string,
      ethBought: BigNumberish,
      maxTokens: BigNumberish,
      deadline: BigNumberish,
      recipient: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;
  };
}