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

import {
  ethers,
  EventFilter,
  Signer,
  BigNumber,
  BigNumberish,
  PopulatedTransaction,
  BaseContract,
  ContractTransaction,
  Overrides,
  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 StakeUSDCInterface extends ethers.utils.Interface {
  functions: {
    "approver()": FunctionFragment;
    "calcReward(address)": FunctionFragment;
    "calcVOTReward(address)": FunctionFragment;
    "claimReward()": FunctionFragment;
    "claimVOTReward()": FunctionFragment;
    "emergencyWithdraw(address,uint256)": FunctionFragment;
    "firstPeriodStartAt()": FunctionFragment;
    "future()": FunctionFragment;
    "getCurrentPeriod()": FunctionFragment;
    "getTimestamp()": FunctionFragment;
    "getUserInfo(address)": FunctionFragment;
    "initRewardVOT(address,uint256,uint256,uint256)": FunctionFragment;
    "minStakeAmount()": FunctionFragment;
    "owner()": FunctionFragment;
    "periodDuration()": FunctionFragment;
    "renounceOwnership()": FunctionFragment;
    "rewardToken()": FunctionFragment;
    "rewardVOT()": FunctionFragment;
    "rewards(uint256)": FunctionFragment;
    "setApprover(address)": FunctionFragment;
    "setFuture(address)": FunctionFragment;
    "setMinStakeAmount(uint256)": FunctionFragment;
    "setPeriodRewardAmount(uint256,uint256)": FunctionFragment;
    "setRewardToken(address)": FunctionFragment;
    "setRewardVOT(uint256,uint256)": FunctionFragment;
    "setStableCoin(address,bool)": FunctionFragment;
    "setSwapPool(address)": FunctionFragment;
    "stableCoinMapper(address)": FunctionFragment;
    "stake(uint256,address)": FunctionFragment;
    "stakeToken()": FunctionFragment;
    "swapPool()": FunctionFragment;
    "totalStakeAmount()": FunctionFragment;
    "totalWithdrawAmount()": FunctionFragment;
    "transferOwnership(address)": FunctionFragment;
    "updateRewardVOT()": FunctionFragment;
    "users(address)": FunctionFragment;
    "withdraw(uint256,address)": FunctionFragment;
  };

  encodeFunctionData(functionFragment: "approver", values?: undefined): string;
  encodeFunctionData(functionFragment: "calcReward", values: [string]): string;
  encodeFunctionData(
    functionFragment: "calcVOTReward",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "claimReward",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "claimVOTReward",
    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: "getTimestamp",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "getUserInfo", values: [string]): string;
  encodeFunctionData(
    functionFragment: "initRewardVOT",
    values: [string, BigNumberish, BigNumberish, BigNumberish]
  ): 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: "rewardVOT", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "rewards",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "setApprover", values: [string]): string;
  encodeFunctionData(functionFragment: "setFuture", values: [string]): string;
  encodeFunctionData(
    functionFragment: "setMinStakeAmount",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setPeriodRewardAmount",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setRewardToken",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setRewardVOT",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setStableCoin",
    values: [string, boolean]
  ): string;
  encodeFunctionData(functionFragment: "setSwapPool", values: [string]): string;
  encodeFunctionData(
    functionFragment: "stableCoinMapper",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "stake",
    values: [BigNumberish, string]
  ): string;
  encodeFunctionData(
    functionFragment: "stakeToken",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "swapPool", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "totalStakeAmount",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "totalWithdrawAmount",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "transferOwnership",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "updateRewardVOT",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "users", values: [string]): string;
  encodeFunctionData(
    functionFragment: "withdraw",
    values: [BigNumberish, string]
  ): string;

  decodeFunctionResult(functionFragment: "approver", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "calcReward", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "calcVOTReward",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "claimReward",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "claimVOTReward",
    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: "getTimestamp",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getUserInfo",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "initRewardVOT",
    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: "rewardVOT", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "rewards", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setApprover",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "setFuture", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setMinStakeAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setPeriodRewardAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setRewardToken",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setRewardVOT",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setStableCoin",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setSwapPool",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "stableCoinMapper",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "stake", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "stakeToken", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "swapPool", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "totalStakeAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "totalWithdrawAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "transferOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateRewardVOT",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "users", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;

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

  getEvent(nameOrSignatureOrTopic: "Claim"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ClaimVOT"): 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 ClaimVOTEvent = TypedEvent<
  [string, BigNumber] & { receiver: string; amount: BigNumber }
>;

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

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

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

export class StakeUSDC 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: StakeUSDCInterface;

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

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

    calcVOTReward(
      _user: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

    claimVOTReward(
      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]>;

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

    getUserInfo(
      _address: string,
      overrides?: CallOverrides
    ): Promise<
      [
        [
          BigNumber,
          BigNumber,
          BigNumber,
          BigNumber,
          BigNumber,
          BigNumber,
          BigNumber
        ] & {
          unClaimedRewardAmount: BigNumber;
          lastStakeAt: BigNumber;
          stakeAmount: BigNumber;
          unCalcRewardPeriod: BigNumber;
          unCalcRewardPeriodStakeAmount: BigNumber;
          rewardDebt: BigNumber;
          unClaimedVOTRewardAmount: BigNumber;
        }
      ] & {
        user: [
          BigNumber,
          BigNumber,
          BigNumber,
          BigNumber,
          BigNumber,
          BigNumber,
          BigNumber
        ] & {
          unClaimedRewardAmount: BigNumber;
          lastStakeAt: BigNumber;
          stakeAmount: BigNumber;
          unCalcRewardPeriod: BigNumber;
          unCalcRewardPeriodStakeAmount: BigNumber;
          rewardDebt: BigNumber;
          unClaimedVOTRewardAmount: BigNumber;
        };
      }
    >;

    initRewardVOT(
      _rewardToken: string,
      _rewardPerSecond: BigNumberish,
      _startTime: BigNumberish,
      _deltaTime: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    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]>;

    rewardVOT(
      overrides?: CallOverrides
    ): Promise<
      [
        string,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber
      ] & {
        rewardToken: string;
        lastRewardTime: BigNumber;
        accERC20PerShare: BigNumber;
        paidOut: BigNumber;
        rewardPerSecond: BigNumber;
        totalReward: BigNumber;
        startTime: BigNumber;
        endTime: BigNumber;
      }
    >;

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

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

    setFuture(
      _newFuture: 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>;

    setRewardVOT(
      _rewardPerSecond: BigNumberish,
      _endTime: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

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

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

    users(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<
      [
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber
      ] & {
        unClaimedRewardAmount: BigNumber;
        lastStakeAt: BigNumber;
        stakeAmount: BigNumber;
        unCalcRewardPeriod: BigNumber;
        unCalcRewardPeriodStakeAmount: BigNumber;
        rewardDebt: BigNumber;
        unClaimedVOTRewardAmount: BigNumber;
      }
    >;

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

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

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

  calcVOTReward(_user: string, overrides?: CallOverrides): Promise<BigNumber>;

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

  claimVOTReward(
    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>;

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

  getUserInfo(
    _address: string,
    overrides?: CallOverrides
  ): Promise<
    [
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber
    ] & {
      unClaimedRewardAmount: BigNumber;
      lastStakeAt: BigNumber;
      stakeAmount: BigNumber;
      unCalcRewardPeriod: BigNumber;
      unCalcRewardPeriodStakeAmount: BigNumber;
      rewardDebt: BigNumber;
      unClaimedVOTRewardAmount: BigNumber;
    }
  >;

  initRewardVOT(
    _rewardToken: string,
    _rewardPerSecond: BigNumberish,
    _startTime: BigNumberish,
    _deltaTime: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  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>;

  rewardVOT(
    overrides?: CallOverrides
  ): Promise<
    [
      string,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber
    ] & {
      rewardToken: string;
      lastRewardTime: BigNumber;
      accERC20PerShare: BigNumber;
      paidOut: BigNumber;
      rewardPerSecond: BigNumber;
      totalReward: BigNumber;
      startTime: BigNumber;
      endTime: BigNumber;
    }
  >;

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

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

  setFuture(
    _newFuture: 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>;

  setRewardVOT(
    _rewardPerSecond: BigNumberish,
    _endTime: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

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

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

  users(
    arg0: string,
    overrides?: CallOverrides
  ): Promise<
    [
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber
    ] & {
      unClaimedRewardAmount: BigNumber;
      lastStakeAt: BigNumber;
      stakeAmount: BigNumber;
      unCalcRewardPeriod: BigNumber;
      unCalcRewardPeriodStakeAmount: BigNumber;
      rewardDebt: BigNumber;
      unClaimedVOTRewardAmount: BigNumber;
    }
  >;

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

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

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

    calcVOTReward(_user: string, overrides?: CallOverrides): Promise<BigNumber>;

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

    claimVOTReward(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>;

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

    getUserInfo(
      _address: string,
      overrides?: CallOverrides
    ): Promise<
      [
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber
      ] & {
        unClaimedRewardAmount: BigNumber;
        lastStakeAt: BigNumber;
        stakeAmount: BigNumber;
        unCalcRewardPeriod: BigNumber;
        unCalcRewardPeriodStakeAmount: BigNumber;
        rewardDebt: BigNumber;
        unClaimedVOTRewardAmount: BigNumber;
      }
    >;

    initRewardVOT(
      _rewardToken: string,
      _rewardPerSecond: BigNumberish,
      _startTime: BigNumberish,
      _deltaTime: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    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>;

    rewardVOT(
      overrides?: CallOverrides
    ): Promise<
      [
        string,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber
      ] & {
        rewardToken: string;
        lastRewardTime: BigNumber;
        accERC20PerShare: BigNumber;
        paidOut: BigNumber;
        rewardPerSecond: BigNumber;
        totalReward: BigNumber;
        startTime: BigNumber;
        endTime: BigNumber;
      }
    >;

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

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

    setFuture(_newFuture: 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>;

    setRewardVOT(
      _rewardPerSecond: BigNumberish,
      _endTime: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

    setSwapPool(_newSwapPool: string, 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>;

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

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

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

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

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

    users(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<
      [
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber
      ] & {
        unClaimedRewardAmount: BigNumber;
        lastStakeAt: BigNumber;
        stakeAmount: BigNumber;
        unCalcRewardPeriod: BigNumber;
        unCalcRewardPeriodStakeAmount: BigNumber;
        rewardDebt: BigNumber;
        unClaimedVOTRewardAmount: BigNumber;
      }
    >;

    withdraw(
      _amount: 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 }
    >;

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

    ClaimVOT(
      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)"(
      account?: null,
      amount?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { account: string; amount: BigNumber }
    >;

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

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

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

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

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

    calcVOTReward(_user: string, overrides?: CallOverrides): Promise<BigNumber>;

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

    claimVOTReward(
      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>;

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

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

    initRewardVOT(
      _rewardToken: string,
      _rewardPerSecond: BigNumberish,
      _startTime: BigNumberish,
      _deltaTime: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): 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>;

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

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

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

    setFuture(
      _newFuture: 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>;

    setRewardVOT(
      _rewardPerSecond: BigNumberish,
      _endTime: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    calcVOTReward(
      _user: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    claimVOTReward(
      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>;

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

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

    initRewardVOT(
      _rewardToken: string,
      _rewardPerSecond: BigNumberish,
      _startTime: BigNumberish,
      _deltaTime: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): 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>;

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

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

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

    setFuture(
      _newFuture: 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>;

    setRewardVOT(
      _rewardPerSecond: BigNumberish,
      _endTime: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

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

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

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

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

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