/* 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 type { TypedEventFilter, TypedEvent, TypedListener } from "./common";

interface StakeOETHProxyInterface extends ethers.utils.Interface {
  functions: {
    "_calcInStakeLpAmount(uint256)": FunctionFragment;
    "_calcOutStakeLpAmount(uint256)": FunctionFragment;
    "approver()": FunctionFragment;
    "calcReward(address)": FunctionFragment;
    "claimReward()": FunctionFragment;
    "emergencyWithdraw(address,uint256)": FunctionFragment;
    "firstPeriodStartAt()": FunctionFragment;
    "future()": FunctionFragment;
    "getCurrentPeriod()": FunctionFragment;
    "getTotalStakeLpAmount()": FunctionFragment;
    "getUserInfo(address)": FunctionFragment;
    "minStakeAmount()": FunctionFragment;
    "owner()": FunctionFragment;
    "periodDuration()": FunctionFragment;
    "renounceOwnership()": FunctionFragment;
    "rewardToken()": FunctionFragment;
    "rewards(uint256)": FunctionFragment;
    "setApprover(address)": FunctionFragment;
    "setMinStakeAmount(uint256)": FunctionFragment;
    "setPeriodRewardAmount(uint256,uint256)": FunctionFragment;
    "setRewardToken(address)": FunctionFragment;
    "setStableCoin(address,bool)": FunctionFragment;
    "stableCoinMapper(address)": FunctionFragment;
    "stake(uint256,address)": FunctionFragment;
    "stakeToken()": FunctionFragment;
    "stakeV1()": FunctionFragment;
    "stakeV1PerLp()": FunctionFragment;
    "totalStakeAmount()": FunctionFragment;
    "totalStakeLpAmount()": FunctionFragment;
    "transferOwnership(address)": FunctionFragment;
    "userStakeV1CalcCompleted(address)": FunctionFragment;
    "users(address)": FunctionFragment;
    "withdraw(uint256,address)": FunctionFragment;
  };

  encodeFunctionData(
    functionFragment: "_calcInStakeLpAmount",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "_calcOutStakeLpAmount",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "approver", values?: undefined): string;
  encodeFunctionData(functionFragment: "calcReward", values: [string]): string;
  encodeFunctionData(
    functionFragment: "claimReward",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "emergencyWithdraw",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "firstPeriodStartAt",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "future", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "getCurrentPeriod",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getTotalStakeLpAmount",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "getUserInfo", values: [string]): string;
  encodeFunctionData(
    functionFragment: "minStakeAmount",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "periodDuration",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "renounceOwnership",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "rewardToken",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "rewards",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "setApprover", values: [string]): string;
  encodeFunctionData(
    functionFragment: "setMinStakeAmount",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setPeriodRewardAmount",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setRewardToken",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setStableCoin",
    values: [string, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "stableCoinMapper",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "stake",
    values: [BigNumberish, string]
  ): string;
  encodeFunctionData(
    functionFragment: "stakeToken",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "stakeV1", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "stakeV1PerLp",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "totalStakeAmount",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "totalStakeLpAmount",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "transferOwnership",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "userStakeV1CalcCompleted",
    values: [string]
  ): string;
  encodeFunctionData(functionFragment: "users", values: [string]): string;
  encodeFunctionData(
    functionFragment: "withdraw",
    values: [BigNumberish, string]
  ): string;

  decodeFunctionResult(
    functionFragment: "_calcInStakeLpAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "_calcOutStakeLpAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "approver", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "calcReward", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "claimReward",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "emergencyWithdraw",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "firstPeriodStartAt",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "future", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getCurrentPeriod",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getTotalStakeLpAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getUserInfo",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "minStakeAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "periodDuration",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "renounceOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "rewardToken",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "rewards", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setApprover",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setMinStakeAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setPeriodRewardAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setRewardToken",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setStableCoin",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "stableCoinMapper",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "stake", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "stakeToken", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "stakeV1", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "stakeV1PerLp",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "totalStakeAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "totalStakeLpAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "transferOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "userStakeV1CalcCompleted",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "users", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;

  events: {
    "Claim(address,uint256)": EventFragment;
    "OwnershipTransferred(address,address)": EventFragment;
    "Stake(address,uint256,uint256)": EventFragment;
    "Withdraw(address,uint256,uint256)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "Claim"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Stake"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Withdraw"): EventFragment;
}

export type ClaimEvent = TypedEvent<
  [string, BigNumber] & { receiver: string; amount: BigNumber }
>;

export type OwnershipTransferredEvent = TypedEvent<
  [string, string] & { previousOwner: string; newOwner: string }
>;

export type StakeEvent = TypedEvent<
  [string, BigNumber, BigNumber] & {
    account: string;
    ethAmount: BigNumber;
    lpAmount: BigNumber;
  }
>;

export type WithdrawEvent = TypedEvent<
  [string, BigNumber, BigNumber] & {
    account: string;
    lpAmount: BigNumber;
    ethAmount: BigNumber;
  }
>;

export class StakeOETHProxy 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: StakeOETHProxyInterface;

  functions: {
    _calcInStakeLpAmount(
      amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { lpAmount: BigNumber }>;

    _calcOutStakeLpAmount(
      lpAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { amount: BigNumber }>;

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

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

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

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

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

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

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

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

    getUserInfo(
      _address: string,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
        unClaimedRewardAmount: BigNumber;
        lastStakeAt: BigNumber;
        stakeLpAmount: BigNumber;
        unCalcRewardPeriod: BigNumber;
        unCalcRewardPeriodStakeLpAmount: BigNumber;
        extractableEthAmount: BigNumber;
      }
    >;

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

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

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

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

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

    rewards(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber, BigNumber, boolean] & {
        startAt: BigNumber;
        endAt: BigNumber;
        rewardAmount: BigNumber;
        stakeLpAmountInPeriod: BigNumber;
        hasRewardBeenSet: boolean;
      }
    >;

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

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

    setPeriodRewardAmount(
      period: BigNumberish,
      rewardAmount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    setStableCoin(
      _token: string,
      _allowed: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    stake(
      _amount: BigNumberish,
      _token: string,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

    users(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
        unClaimedRewardAmount: BigNumber;
        lastStakeAt: BigNumber;
        unCalcRewardPeriod: BigNumber;
        unCalcRewardPeriodStakeLpAmount: BigNumber;
        stakeLpAmount: BigNumber;
      }
    >;

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

  _calcInStakeLpAmount(
    amount: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  _calcOutStakeLpAmount(
    lpAmount: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

  getUserInfo(
    _address: string,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
      unClaimedRewardAmount: BigNumber;
      lastStakeAt: BigNumber;
      stakeLpAmount: BigNumber;
      unCalcRewardPeriod: BigNumber;
      unCalcRewardPeriodStakeLpAmount: BigNumber;
      extractableEthAmount: BigNumber;
    }
  >;

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

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

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

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

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

  rewards(
    arg0: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber, BigNumber, BigNumber, boolean] & {
      startAt: BigNumber;
      endAt: BigNumber;
      rewardAmount: BigNumber;
      stakeLpAmountInPeriod: BigNumber;
      hasRewardBeenSet: boolean;
    }
  >;

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

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

  setPeriodRewardAmount(
    period: BigNumberish,
    rewardAmount: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  setStableCoin(
    _token: string,
    _allowed: boolean,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  stake(
    _amount: BigNumberish,
    _token: string,
    overrides?: PayableOverrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

  users(
    arg0: string,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
      unClaimedRewardAmount: BigNumber;
      lastStakeAt: BigNumber;
      unCalcRewardPeriod: BigNumber;
      unCalcRewardPeriodStakeLpAmount: BigNumber;
      stakeLpAmount: BigNumber;
    }
  >;

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

  callStatic: {
    _calcInStakeLpAmount(
      amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    _calcOutStakeLpAmount(
      lpAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

    emergencyWithdraw(
      token: string,
      amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

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

    getUserInfo(
      _address: string,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
        unClaimedRewardAmount: BigNumber;
        lastStakeAt: BigNumber;
        stakeLpAmount: BigNumber;
        unCalcRewardPeriod: BigNumber;
        unCalcRewardPeriodStakeLpAmount: BigNumber;
        extractableEthAmount: BigNumber;
      }
    >;

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

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

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

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

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

    rewards(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber, BigNumber, boolean] & {
        startAt: BigNumber;
        endAt: BigNumber;
        rewardAmount: BigNumber;
        stakeLpAmountInPeriod: BigNumber;
        hasRewardBeenSet: boolean;
      }
    >;

    setApprover(_newApprover: string, overrides?: CallOverrides): Promise<void>;

    setMinStakeAmount(
      _minStakeAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setPeriodRewardAmount(
      period: BigNumberish,
      rewardAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setRewardToken(_token: string, overrides?: CallOverrides): Promise<void>;

    setStableCoin(
      _token: string,
      _allowed: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

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

    stake(
      _amount: BigNumberish,
      _token: string,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

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

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

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

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

    users(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
        unClaimedRewardAmount: BigNumber;
        lastStakeAt: BigNumber;
        unCalcRewardPeriod: BigNumber;
        unCalcRewardPeriodStakeLpAmount: BigNumber;
        stakeLpAmount: BigNumber;
      }
    >;

    withdraw(
      _lpAmount: BigNumberish,
      _token: string,
      overrides?: CallOverrides
    ): Promise<void>;
  };

  filters: {
    "Claim(address,uint256)"(
      receiver?: null,
      amount?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { receiver: string; amount: BigNumber }
    >;

    Claim(
      receiver?: null,
      amount?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { receiver: string; amount: BigNumber }
    >;

    "OwnershipTransferred(address,address)"(
      previousOwner?: string | null,
      newOwner?: string | null
    ): TypedEventFilter<
      [string, string],
      { previousOwner: string; newOwner: string }
    >;

    OwnershipTransferred(
      previousOwner?: string | null,
      newOwner?: string | null
    ): TypedEventFilter<
      [string, string],
      { previousOwner: string; newOwner: string }
    >;

    "Stake(address,uint256,uint256)"(
      account?: null,
      ethAmount?: null,
      lpAmount?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber],
      { account: string; ethAmount: BigNumber; lpAmount: BigNumber }
    >;

    Stake(
      account?: null,
      ethAmount?: null,
      lpAmount?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber],
      { account: string; ethAmount: BigNumber; lpAmount: BigNumber }
    >;

    "Withdraw(address,uint256,uint256)"(
      account?: null,
      lpAmount?: null,
      ethAmount?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber],
      { account: string; lpAmount: BigNumber; ethAmount: BigNumber }
    >;

    Withdraw(
      account?: null,
      lpAmount?: null,
      ethAmount?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber],
      { account: string; lpAmount: BigNumber; ethAmount: BigNumber }
    >;
  };

  estimateGas: {
    _calcInStakeLpAmount(
      amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    _calcOutStakeLpAmount(
      lpAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    setPeriodRewardAmount(
      period: BigNumberish,
      rewardAmount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    setStableCoin(
      _token: string,
      _allowed: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    stake(
      _amount: BigNumberish,
      _token: string,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

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

  populateTransaction: {
    _calcInStakeLpAmount(
      amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    _calcOutStakeLpAmount(
      lpAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    setPeriodRewardAmount(
      period: BigNumberish,
      rewardAmount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    setStableCoin(
      _token: string,
      _allowed: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    stake(
      _amount: BigNumberish,
      _token: string,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

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

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