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

import {
  ethers,
  EventFilter,
  Signer,
  BigNumber,
  BigNumberish,
  PopulatedTransaction,
  BaseContract,
  ContractTransaction,
  Overrides,
  PayableOverrides,
  CallOverrides,
} from "ethers";
import { BytesLike } from "@ethersproject/bytes";
import { Listener, Provider } from "@ethersproject/providers";
import { FunctionFragment, EventFragment, Result } from "@ethersproject/abi";
import { TypedEventFilter, TypedEvent, TypedListener } from "./commons";

interface FarmingPoolAbiInterface extends ethers.utils.Interface {
  functions: {
    "MAX_POOL_LENGTH()": FunctionFragment;
    "MULTIPLIER()": FunctionFragment;
    "addBonusPool(tuple)": FunctionFragment;
    "changeRPS(uint256)": FunctionFragment;
    "claimRewards(uint256,bool)": FunctionFragment;
    "claimRewardsAll()": FunctionFragment;
    "deposit(uint256)": FunctionFragment;
    "factory()": FunctionFragment;
    "getActualPools()": FunctionFragment;
    "getFarmingState()": FunctionFragment;
    "getUserDeposits(address)": FunctionFragment;
    "initialize(address,address,address,address,tuple,tuple)": FunctionFragment;
    "intermediate()": FunctionFragment;
    "liquidityPool()": FunctionFragment;
    "pendingReward(address,uint256)": FunctionFragment;
    "pendingRewardsMultiple(address)": FunctionFragment;
    "pool()": FunctionFragment;
    "rewardPools(uint256)": FunctionFragment;
    "router()": FunctionFragment;
    "stopBonusPool(uint256)": FunctionFragment;
    "stopMainPool()": FunctionFragment;
    "unzap(address,uint256[3])": FunctionFragment;
    "wbone()": FunctionFragment;
    "withdraw()": FunctionFragment;
    "zap(address,uint256,uint256[3])": FunctionFragment;
  };

  encodeFunctionData(
    functionFragment: "MAX_POOL_LENGTH",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "MULTIPLIER",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "addBonusPool",
    values: [
      {
        rewardToken: string;
        startTime: BigNumberish;
        endTime: BigNumberish;
        rps: BigNumberish;
      }
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "changeRPS",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "claimRewards",
    values: [BigNumberish, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "claimRewardsAll",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "deposit",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "factory", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "getActualPools",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getFarmingState",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getUserDeposits",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "initialize",
    values: [
      string,
      string,
      string,
      string,
      { token0: string; token1: string },
      {
        rewardToken: string;
        startTime: BigNumberish;
        endTime: BigNumberish;
        rps: BigNumberish;
      }
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "intermediate",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "liquidityPool",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "pendingReward",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "pendingRewardsMultiple",
    values: [string]
  ): string;
  encodeFunctionData(functionFragment: "pool", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "rewardPools",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "router", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "stopBonusPool",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "stopMainPool",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "unzap",
    values: [string, [BigNumberish, BigNumberish, BigNumberish]]
  ): string;
  encodeFunctionData(functionFragment: "wbone", values?: undefined): string;
  encodeFunctionData(functionFragment: "withdraw", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "zap",
    values: [string, BigNumberish, [BigNumberish, BigNumberish, BigNumberish]]
  ): string;

  decodeFunctionResult(
    functionFragment: "MAX_POOL_LENGTH",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "MULTIPLIER", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "addBonusPool",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "changeRPS", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "claimRewards",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "claimRewardsAll",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "deposit", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "factory", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getActualPools",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getFarmingState",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getUserDeposits",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "intermediate",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "liquidityPool",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "pendingReward",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "pendingRewardsMultiple",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "pool", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "rewardPools",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "router", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "stopBonusPool",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "stopMainPool",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "unzap", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "wbone", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "zap", data: BytesLike): Result;

  events: {
    "BonusPoolAdded(uint256,address,uint64,uint64,uint256)": EventFragment;
    "BonusPoolStopped(uint256)": EventFragment;
    "ClaimedReward(address,uint256,bool,address,uint256)": EventFragment;
    "Deposited(address,uint256)": EventFragment;
    "Initialized(uint64)": EventFragment;
    "MainRewardPoolStopped()": EventFragment;
    "RewardPerSecondChanged(uint256)": EventFragment;
    "Unzap(address,uint256,uint256)": EventFragment;
    "Withdrawed(address,uint256)": EventFragment;
    "Zap(address,uint256,uint256)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "BonusPoolAdded"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "BonusPoolStopped"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ClaimedReward"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Deposited"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "MainRewardPoolStopped"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RewardPerSecondChanged"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Unzap"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Withdrawed"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Zap"): EventFragment;
}

export type BonusPoolAddedEvent = TypedEvent<
  [BigNumber, string, BigNumber, BigNumber, BigNumber] & {
    poolId: BigNumber;
    rewardToken: string;
    starts: BigNumber;
    ends: BigNumber;
    rps: BigNumber;
  }
>;

export type BonusPoolStoppedEvent = TypedEvent<
  [BigNumber] & { poolId: BigNumber }
>;

export type ClaimedRewardEvent = TypedEvent<
  [string, BigNumber, boolean, string, BigNumber] & {
    user: string;
    poolId: BigNumber;
    fromZap: boolean;
    rewardToken: string;
    amount: BigNumber;
  }
>;

export type DepositedEvent = TypedEvent<
  [string, BigNumber] & { user: string; liquidity: BigNumber }
>;

export type InitializedEvent = TypedEvent<[BigNumber] & { version: BigNumber }>;

export type MainRewardPoolStoppedEvent = TypedEvent<[] & {}>;

export type RewardPerSecondChangedEvent = TypedEvent<
  [BigNumber] & { rps: BigNumber }
>;

export type UnzapEvent = TypedEvent<
  [string, BigNumber, BigNumber] & {
    outputToken: string;
    amount: BigNumber;
    fee: BigNumber;
  }
>;

export type WithdrawedEvent = TypedEvent<
  [string, BigNumber] & { user: string; liquidity: BigNumber }
>;

export type ZapEvent = TypedEvent<
  [string, BigNumber, BigNumber] & {
    inputToken: string;
    amount: BigNumber;
    fee: BigNumber;
  }
>;

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

  listeners<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter?: TypedEventFilter<EventArgsArray, EventArgsObject>
  ): Array<TypedListener<EventArgsArray, EventArgsObject>>;
  off<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  on<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  once<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  removeListener<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  removeAllListeners<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>
  ): this;

  listeners(eventName?: string): Array<Listener>;
  off(eventName: string, listener: Listener): this;
  on(eventName: string, listener: Listener): this;
  once(eventName: string, listener: Listener): this;
  removeListener(eventName: string, listener: Listener): this;
  removeAllListeners(eventName?: string): this;

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

  interface: FarmingPoolAbiInterface;

  functions: {
    MAX_POOL_LENGTH(overrides?: CallOverrides): Promise<[number]>;

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

    addBonusPool(
      rew: {
        rewardToken: string;
        startTime: BigNumberish;
        endTime: BigNumberish;
        rps: BigNumberish;
      },
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

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

    getActualPools(
      overrides?: CallOverrides
    ): Promise<
      [
        BigNumber[],
        ([string, BigNumber, BigNumber, BigNumber] & {
          rewardToken: string;
          startTime: BigNumber;
          endTime: BigNumber;
          rps: BigNumber;
        })[]
      ] & {
        ids: BigNumber[];
        pools: ([string, BigNumber, BigNumber, BigNumber] & {
          rewardToken: string;
          startTime: BigNumber;
          endTime: BigNumber;
          rps: BigNumber;
        })[];
      }
    >;

    getFarmingState(
      overrides?: CallOverrides
    ): Promise<
      [
        [BigNumber, BigNumber[], BigNumber[]] & {
          totalLiquidity: BigNumber;
          lastUpdate: BigNumber[];
          accumulators: BigNumber[];
        }
      ]
    >;

    getUserDeposits(
      user: string,
      overrides?: CallOverrides
    ): Promise<
      [
        [
          [BigNumber, BigNumber[], BigNumber[]] & {
            liquidity: BigNumber;
            accumulators: BigNumber[];
            debts: BigNumber[];
          },
          [BigNumber, BigNumber[], BigNumber[]] & {
            liquidity: BigNumber;
            accumulators: BigNumber[];
            debts: BigNumber[];
          }
        ]
      ] & {
        deps: [
          [BigNumber, BigNumber[], BigNumber[]] & {
            liquidity: BigNumber;
            accumulators: BigNumber[];
            debts: BigNumber[];
          },
          [BigNumber, BigNumber[], BigNumber[]] & {
            liquidity: BigNumber;
            accumulators: BigNumber[];
            debts: BigNumber[];
          }
        ];
      }
    >;

    initialize(
      _factory: string,
      _router: string,
      _pool: string,
      _wbone: string,
      _liq: { token0: string; token1: string },
      _rew: {
        rewardToken: string;
        startTime: BigNumberish;
        endTime: BigNumberish;
        rps: BigNumberish;
      },
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    intermediate(
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { totalLiquidity: BigNumber }>;

    liquidityPool(
      overrides?: CallOverrides
    ): Promise<[string, string] & { token0: string; token1: string }>;

    pendingReward(
      user: string,
      poolId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & { fromStake: BigNumber; fromZap: BigNumber }
    >;

    pendingRewardsMultiple(
      user: string,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber[], BigNumber[]] & {
        fromStake: BigNumber[];
        fromZap: BigNumber[];
      }
    >;

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

    rewardPools(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [string, BigNumber, BigNumber, BigNumber] & {
        rewardToken: string;
        startTime: BigNumber;
        endTime: BigNumber;
        rps: BigNumber;
      }
    >;

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

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

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

    unzap(
      tokenOut: string,
      minAmountOuts: [BigNumberish, BigNumberish, BigNumberish],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

    zap(
      inputToken: string,
      amount: BigNumberish,
      minAmountOuts: [BigNumberish, BigNumberish, BigNumberish],
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;
  };

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

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

  addBonusPool(
    rew: {
      rewardToken: string;
      startTime: BigNumberish;
      endTime: BigNumberish;
      rps: BigNumberish;
    },
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

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

  getActualPools(
    overrides?: CallOverrides
  ): Promise<
    [
      BigNumber[],
      ([string, BigNumber, BigNumber, BigNumber] & {
        rewardToken: string;
        startTime: BigNumber;
        endTime: BigNumber;
        rps: BigNumber;
      })[]
    ] & {
      ids: BigNumber[];
      pools: ([string, BigNumber, BigNumber, BigNumber] & {
        rewardToken: string;
        startTime: BigNumber;
        endTime: BigNumber;
        rps: BigNumber;
      })[];
    }
  >;

  getFarmingState(
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber[], BigNumber[]] & {
      totalLiquidity: BigNumber;
      lastUpdate: BigNumber[];
      accumulators: BigNumber[];
    }
  >;

  getUserDeposits(
    user: string,
    overrides?: CallOverrides
  ): Promise<
    [
      [BigNumber, BigNumber[], BigNumber[]] & {
        liquidity: BigNumber;
        accumulators: BigNumber[];
        debts: BigNumber[];
      },
      [BigNumber, BigNumber[], BigNumber[]] & {
        liquidity: BigNumber;
        accumulators: BigNumber[];
        debts: BigNumber[];
      }
    ]
  >;

  initialize(
    _factory: string,
    _router: string,
    _pool: string,
    _wbone: string,
    _liq: { token0: string; token1: string },
    _rew: {
      rewardToken: string;
      startTime: BigNumberish;
      endTime: BigNumberish;
      rps: BigNumberish;
    },
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  liquidityPool(
    overrides?: CallOverrides
  ): Promise<[string, string] & { token0: string; token1: string }>;

  pendingReward(
    user: string,
    poolId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber] & { fromStake: BigNumber; fromZap: BigNumber }
  >;

  pendingRewardsMultiple(
    user: string,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber[], BigNumber[]] & {
      fromStake: BigNumber[];
      fromZap: BigNumber[];
    }
  >;

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

  rewardPools(
    arg0: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    [string, BigNumber, BigNumber, BigNumber] & {
      rewardToken: string;
      startTime: BigNumber;
      endTime: BigNumber;
      rps: BigNumber;
    }
  >;

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

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

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

  unzap(
    tokenOut: string,
    minAmountOuts: [BigNumberish, BigNumberish, BigNumberish],
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

  zap(
    inputToken: string,
    amount: BigNumberish,
    minAmountOuts: [BigNumberish, BigNumberish, BigNumberish],
    overrides?: PayableOverrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  callStatic: {
    MAX_POOL_LENGTH(overrides?: CallOverrides): Promise<number>;

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

    addBonusPool(
      rew: {
        rewardToken: string;
        startTime: BigNumberish;
        endTime: BigNumberish;
        rps: BigNumberish;
      },
      overrides?: CallOverrides
    ): Promise<void>;

    changeRPS(value: BigNumberish, overrides?: CallOverrides): Promise<void>;

    claimRewards(
      poolId: BigNumberish,
      fromStake: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

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

    deposit(amount: BigNumberish, overrides?: CallOverrides): Promise<void>;

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

    getActualPools(
      overrides?: CallOverrides
    ): Promise<
      [
        BigNumber[],
        ([string, BigNumber, BigNumber, BigNumber] & {
          rewardToken: string;
          startTime: BigNumber;
          endTime: BigNumber;
          rps: BigNumber;
        })[]
      ] & {
        ids: BigNumber[];
        pools: ([string, BigNumber, BigNumber, BigNumber] & {
          rewardToken: string;
          startTime: BigNumber;
          endTime: BigNumber;
          rps: BigNumber;
        })[];
      }
    >;

    getFarmingState(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber[], BigNumber[]] & {
        totalLiquidity: BigNumber;
        lastUpdate: BigNumber[];
        accumulators: BigNumber[];
      }
    >;

    getUserDeposits(
      user: string,
      overrides?: CallOverrides
    ): Promise<
      [
        [BigNumber, BigNumber[], BigNumber[]] & {
          liquidity: BigNumber;
          accumulators: BigNumber[];
          debts: BigNumber[];
        },
        [BigNumber, BigNumber[], BigNumber[]] & {
          liquidity: BigNumber;
          accumulators: BigNumber[];
          debts: BigNumber[];
        }
      ]
    >;

    initialize(
      _factory: string,
      _router: string,
      _pool: string,
      _wbone: string,
      _liq: { token0: string; token1: string },
      _rew: {
        rewardToken: string;
        startTime: BigNumberish;
        endTime: BigNumberish;
        rps: BigNumberish;
      },
      overrides?: CallOverrides
    ): Promise<void>;

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

    liquidityPool(
      overrides?: CallOverrides
    ): Promise<[string, string] & { token0: string; token1: string }>;

    pendingReward(
      user: string,
      poolId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & { fromStake: BigNumber; fromZap: BigNumber }
    >;

    pendingRewardsMultiple(
      user: string,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber[], BigNumber[]] & {
        fromStake: BigNumber[];
        fromZap: BigNumber[];
      }
    >;

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

    rewardPools(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [string, BigNumber, BigNumber, BigNumber] & {
        rewardToken: string;
        startTime: BigNumber;
        endTime: BigNumber;
        rps: BigNumber;
      }
    >;

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

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

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

    unzap(
      tokenOut: string,
      minAmountOuts: [BigNumberish, BigNumberish, BigNumberish],
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    zap(
      inputToken: string,
      amount: BigNumberish,
      minAmountOuts: [BigNumberish, BigNumberish, BigNumberish],
      overrides?: CallOverrides
    ): Promise<void>;
  };

  filters: {
    "BonusPoolAdded(uint256,address,uint64,uint64,uint256)"(
      poolId?: null,
      rewardToken?: null,
      starts?: null,
      ends?: null,
      rps?: null
    ): TypedEventFilter<
      [BigNumber, string, BigNumber, BigNumber, BigNumber],
      {
        poolId: BigNumber;
        rewardToken: string;
        starts: BigNumber;
        ends: BigNumber;
        rps: BigNumber;
      }
    >;

    BonusPoolAdded(
      poolId?: null,
      rewardToken?: null,
      starts?: null,
      ends?: null,
      rps?: null
    ): TypedEventFilter<
      [BigNumber, string, BigNumber, BigNumber, BigNumber],
      {
        poolId: BigNumber;
        rewardToken: string;
        starts: BigNumber;
        ends: BigNumber;
        rps: BigNumber;
      }
    >;

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

    BonusPoolStopped(
      poolId?: null
    ): TypedEventFilter<[BigNumber], { poolId: BigNumber }>;

    "ClaimedReward(address,uint256,bool,address,uint256)"(
      user?: null,
      poolId?: null,
      fromZap?: null,
      rewardToken?: null,
      amount?: null
    ): TypedEventFilter<
      [string, BigNumber, boolean, string, BigNumber],
      {
        user: string;
        poolId: BigNumber;
        fromZap: boolean;
        rewardToken: string;
        amount: BigNumber;
      }
    >;

    ClaimedReward(
      user?: null,
      poolId?: null,
      fromZap?: null,
      rewardToken?: null,
      amount?: null
    ): TypedEventFilter<
      [string, BigNumber, boolean, string, BigNumber],
      {
        user: string;
        poolId: BigNumber;
        fromZap: boolean;
        rewardToken: string;
        amount: BigNumber;
      }
    >;

    "Deposited(address,uint256)"(
      user?: null,
      liquidity?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { user: string; liquidity: BigNumber }
    >;

    Deposited(
      user?: null,
      liquidity?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { user: string; liquidity: BigNumber }
    >;

    "Initialized(uint64)"(
      version?: null
    ): TypedEventFilter<[BigNumber], { version: BigNumber }>;

    Initialized(
      version?: null
    ): TypedEventFilter<[BigNumber], { version: BigNumber }>;

    "MainRewardPoolStopped()"(): TypedEventFilter<[], {}>;

    MainRewardPoolStopped(): TypedEventFilter<[], {}>;

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

    RewardPerSecondChanged(
      rps?: null
    ): TypedEventFilter<[BigNumber], { rps: BigNumber }>;

    "Unzap(address,uint256,uint256)"(
      outputToken?: null,
      amount?: null,
      fee?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber],
      { outputToken: string; amount: BigNumber; fee: BigNumber }
    >;

    Unzap(
      outputToken?: null,
      amount?: null,
      fee?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber],
      { outputToken: string; amount: BigNumber; fee: BigNumber }
    >;

    "Withdrawed(address,uint256)"(
      user?: null,
      liquidity?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { user: string; liquidity: BigNumber }
    >;

    Withdrawed(
      user?: null,
      liquidity?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { user: string; liquidity: BigNumber }
    >;

    "Zap(address,uint256,uint256)"(
      inputToken?: null,
      amount?: null,
      fee?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber],
      { inputToken: string; amount: BigNumber; fee: BigNumber }
    >;

    Zap(
      inputToken?: null,
      amount?: null,
      fee?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber],
      { inputToken: string; amount: BigNumber; fee: BigNumber }
    >;
  };

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

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

    addBonusPool(
      rew: {
        rewardToken: string;
        startTime: BigNumberish;
        endTime: BigNumberish;
        rps: BigNumberish;
      },
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

    initialize(
      _factory: string,
      _router: string,
      _pool: string,
      _wbone: string,
      _liq: { token0: string; token1: string },
      _rew: {
        rewardToken: string;
        startTime: BigNumberish;
        endTime: BigNumberish;
        rps: BigNumberish;
      },
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

    pendingReward(
      user: string,
      poolId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

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

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

    unzap(
      tokenOut: string,
      minAmountOuts: [BigNumberish, BigNumberish, BigNumberish],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

    zap(
      inputToken: string,
      amount: BigNumberish,
      minAmountOuts: [BigNumberish, BigNumberish, BigNumberish],
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;
  };

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

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

    addBonusPool(
      rew: {
        rewardToken: string;
        startTime: BigNumberish;
        endTime: BigNumberish;
        rps: BigNumberish;
      },
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

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

    initialize(
      _factory: string,
      _router: string,
      _pool: string,
      _wbone: string,
      _liq: { token0: string; token1: string },
      _rew: {
        rewardToken: string;
        startTime: BigNumberish;
        endTime: BigNumberish;
        rps: BigNumberish;
      },
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

    pendingReward(
      user: string,
      poolId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

    unzap(
      tokenOut: string,
      minAmountOuts: [BigNumberish, BigNumberish, BigNumberish],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

    zap(
      inputToken: string,
      amount: BigNumberish,
      minAmountOuts: [BigNumberish, BigNumberish, BigNumberish],
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;
  };
}