/* 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 StakeVOTInterface extends ethers.utils.Interface {
  functions: {
    "calcBP(uint256,address)": FunctionFragment;
    "calcReward(address)": FunctionFragment;
    "claimReward()": FunctionFragment;
    "emergencyWithdraw(address,uint256)": FunctionFragment;
    "firstPeriodStartAt()": FunctionFragment;
    "getCurrentPeriod()": FunctionFragment;
    "getStakeRecords(address)": FunctionFragment;
    "getTimestamp()": FunctionFragment;
    "getUserInfo(address)": FunctionFragment;
    "minStakeAmount()": FunctionFragment;
    "owner()": FunctionFragment;
    "periodDuration()": FunctionFragment;
    "redeem(uint256,uint256)": FunctionFragment;
    "redeemInfo()": FunctionFragment;
    "renounceOwnership()": FunctionFragment;
    "rewardToken()": FunctionFragment;
    "rewards(uint256)": FunctionFragment;
    "setApprover(address)": FunctionFragment;
    "setIsCanRedeem(bool)": FunctionFragment;
    "setMinStakeAmount(uint256)": FunctionFragment;
    "setPeriodRewardAmount(uint256,uint256)": FunctionFragment;
    "setRedeemInfoMinStakeDuration(uint256)": FunctionFragment;
    "setRewardToken(address)": FunctionFragment;
    "setTreasury(uint256)": FunctionFragment;
    "setVOTCirculatingSupply(uint256)": FunctionFragment;
    "stake(uint256)": FunctionFragment;
    "stakeBpAmount()": FunctionFragment;
    "stakeLastBpTime()": FunctionFragment;
    "stakeToken()": FunctionFragment;
    "totalStakeAmount()": FunctionFragment;
    "transferOwnership(address)": FunctionFragment;
    "userStakeRecords(address,uint256)": FunctionFragment;
    "users(address)": FunctionFragment;
    "withdraw(uint256,uint256)": FunctionFragment;
  };

  encodeFunctionData(
    functionFragment: "calcBP",
    values: [BigNumberish, string]
  ): 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: "getCurrentPeriod",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getStakeRecords",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "getTimestamp",
    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: "redeem",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "redeemInfo",
    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: "setIsCanRedeem",
    values: [boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "setMinStakeAmount",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setPeriodRewardAmount",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setRedeemInfoMinStakeDuration",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setRewardToken",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setTreasury",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setVOTCirculatingSupply",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "stake", values: [BigNumberish]): string;
  encodeFunctionData(
    functionFragment: "stakeBpAmount",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "stakeLastBpTime",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "stakeToken",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "totalStakeAmount",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "transferOwnership",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "userStakeRecords",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "users", values: [string]): string;
  encodeFunctionData(
    functionFragment: "withdraw",
    values: [BigNumberish, BigNumberish]
  ): string;

  decodeFunctionResult(functionFragment: "calcBP", 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: "getCurrentPeriod",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getStakeRecords",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getTimestamp",
    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: "redeem", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "redeemInfo", 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: "setIsCanRedeem",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setMinStakeAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setPeriodRewardAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setRedeemInfoMinStakeDuration",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setRewardToken",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setTreasury",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setVOTCirculatingSupply",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "stake", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "stakeBpAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "stakeLastBpTime",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "stakeToken", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "totalStakeAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "transferOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "userStakeRecords",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "users", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;

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

  getEvent(nameOrSignatureOrTopic: "Claim"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Redeem"): 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 RedeemEvent = TypedEvent<
  [string, BigNumber, BigNumber] & {
    account: string;
    claimedAmount: BigNumber;
    balance: BigNumber;
  }
>;

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 StakeVOT 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: StakeVOTInterface;

  functions: {
    calcBP(
      timestamp: BigNumberish,
      _address: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

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

    getStakeRecords(
      _account: string,
      overrides?: CallOverrides
    ): Promise<
      [([BigNumber, BigNumber] & { amount: BigNumber; stakeAt: BigNumber })[]]
    >;

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

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

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

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

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

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

    redeemInfo(
      overrides?: CallOverrides
    ): Promise<
      [boolean, BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
        isCanRedeem: boolean;
        treasury: BigNumber;
        minStakeDuration: BigNumber;
        fee: BigNumber;
        circulatingSupply: BigNumber;
        totalRedeemAmount: 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, BigNumber] & {
        startAt: BigNumber;
        endAt: BigNumber;
        rewardAmount: BigNumber;
        stakeAmountInPeriod: BigNumber;
        stakeBPAmountInPeriod: BigNumber;
      }
    >;

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

    setIsCanRedeem(
      isCanRedeem: boolean,
      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>;

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

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

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

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

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

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

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

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

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

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

    userStakeRecords(
      arg0: string,
      arg1: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & { amount: BigNumber; stakeAt: BigNumber }
    >;

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

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

  calcBP(
    timestamp: BigNumberish,
    _address: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

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

  getStakeRecords(
    _account: string,
    overrides?: CallOverrides
  ): Promise<
    ([BigNumber, BigNumber] & { amount: BigNumber; stakeAt: BigNumber })[]
  >;

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

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

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

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

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

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

  redeemInfo(
    overrides?: CallOverrides
  ): Promise<
    [boolean, BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
      isCanRedeem: boolean;
      treasury: BigNumber;
      minStakeDuration: BigNumber;
      fee: BigNumber;
      circulatingSupply: BigNumber;
      totalRedeemAmount: 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, BigNumber] & {
      startAt: BigNumber;
      endAt: BigNumber;
      rewardAmount: BigNumber;
      stakeAmountInPeriod: BigNumber;
      stakeBPAmountInPeriod: BigNumber;
    }
  >;

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

  setIsCanRedeem(
    isCanRedeem: boolean,
    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>;

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

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

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

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

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

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

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

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

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

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

  userStakeRecords(
    arg0: string,
    arg1: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber] & { amount: BigNumber; stakeAt: BigNumber }
  >;

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

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

  callStatic: {
    calcBP(
      timestamp: BigNumberish,
      _address: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    getStakeRecords(
      _account: string,
      overrides?: CallOverrides
    ): Promise<
      ([BigNumber, BigNumber] & { amount: BigNumber; stakeAt: BigNumber })[]
    >;

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

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

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

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

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

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

    redeemInfo(
      overrides?: CallOverrides
    ): Promise<
      [boolean, BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
        isCanRedeem: boolean;
        treasury: BigNumber;
        minStakeDuration: BigNumber;
        fee: BigNumber;
        circulatingSupply: BigNumber;
        totalRedeemAmount: BigNumber;
      }
    >;

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

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

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

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

    setIsCanRedeem(
      isCanRedeem: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    setRedeemInfoMinStakeDuration(
      minStakeDuration: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

    setTreasury(
      treasury: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setVOTCirculatingSupply(
      circulatingSupply: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

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

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

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

    userStakeRecords(
      arg0: string,
      arg1: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & { amount: BigNumber; stakeAt: BigNumber }
    >;

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

    withdraw(
      amount: BigNumberish,
      _recordIndex: BigNumberish,
      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 }
    >;

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

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

    "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: {
    calcBP(
      timestamp: BigNumberish,
      _address: string,
      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>;

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

    getStakeRecords(
      _account: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

    setIsCanRedeem(
      isCanRedeem: boolean,
      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>;

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

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

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

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

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

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

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

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

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

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

    userStakeRecords(
      arg0: string,
      arg1: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

  populateTransaction: {
    calcBP(
      timestamp: BigNumberish,
      _address: string,
      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>;

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

    getStakeRecords(
      _account: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

    setIsCanRedeem(
      isCanRedeem: boolean,
      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>;

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

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

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

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

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

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

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

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

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

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

    userStakeRecords(
      arg0: string,
      arg1: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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