/* 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 StakeInterface extends ethers.utils.Interface {
  functions: {
    "ACC_PRECISION()": FunctionFragment;
    "MAXCOEF()": FunctionFragment;
    "candidateInfo(address)": FunctionFragment;
    "claim(address)": FunctionFragment;
    "claimFrozenPeriod()": FunctionFragment;
    "downgrade(address)": FunctionFragment;
    "draftSlash(address,uint256)": FunctionFragment;
    "election()": FunctionFragment;
    "executeSlash(address,uint256,address[],uint256[],uint256)": FunctionFragment;
    "gradeOf(address)": FunctionFragment;
    "initialize(address,address,address,address,address,uint256,uint256,uint256)": FunctionFragment;
    "isCandidateRegistered(address)": FunctionFragment;
    "isClaimUnfrozen(address)": FunctionFragment;
    "isStakeUnfrozen(address)": FunctionFragment;
    "lastClaimTimestamp(address)": FunctionFragment;
    "lastStakeTimestamp(address)": FunctionFragment;
    "majorCandidateManifests()": FunctionFragment;
    "majorCandidates()": FunctionFragment;
    "manifestMap(string)": FunctionFragment;
    "minStake()": FunctionFragment;
    "pendingCandidateAllocation(address)": FunctionFragment;
    "pendingReward(address)": FunctionFragment;
    "pendingVoterAllocation(address)": FunctionFragment;
    "poolExists(uint8)": FunctionFragment;
    "poolInfo(uint8)": FunctionFragment;
    "quit(address)": FunctionFragment;
    "register(string)": FunctionFragment;
    "registerAndStake(uint256,string)": FunctionFragment;
    "rejectSlash(address,uint256)": FunctionFragment;
    "rewardPerSecond()": FunctionFragment;
    "rewarder()": FunctionFragment;
    "setVoteRewardCoef(uint256)": FunctionFragment;
    "slasher()": FunctionFragment;
    "stake(uint256)": FunctionFragment;
    "stakeFrozenPeriod()": FunctionFragment;
    "token()": FunctionFragment;
    "totalAllocPoint()": FunctionFragment;
    "updatePool(uint8)": FunctionFragment;
    "upgrade(address)": FunctionFragment;
    "voteRewardCoef(address)": FunctionFragment;
    "voterAllocate(address)": FunctionFragment;
  };

  encodeFunctionData(
    functionFragment: "ACC_PRECISION",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "MAXCOEF", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "candidateInfo",
    values: [string]
  ): string;
  encodeFunctionData(functionFragment: "claim", values: [string]): string;
  encodeFunctionData(
    functionFragment: "claimFrozenPeriod",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "downgrade", values: [string]): string;
  encodeFunctionData(
    functionFragment: "draftSlash",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "election", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "executeSlash",
    values: [string, BigNumberish, string[], BigNumberish[], BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "gradeOf", values: [string]): string;
  encodeFunctionData(
    functionFragment: "initialize",
    values: [
      string,
      string,
      string,
      string,
      string,
      BigNumberish,
      BigNumberish,
      BigNumberish
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "isCandidateRegistered",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "isClaimUnfrozen",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "isStakeUnfrozen",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "lastClaimTimestamp",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "lastStakeTimestamp",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "majorCandidateManifests",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "majorCandidates",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "manifestMap", values: [string]): string;
  encodeFunctionData(functionFragment: "minStake", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "pendingCandidateAllocation",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "pendingReward",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "pendingVoterAllocation",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "poolExists",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "poolInfo",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "quit", values: [string]): string;
  encodeFunctionData(functionFragment: "register", values: [string]): string;
  encodeFunctionData(
    functionFragment: "registerAndStake",
    values: [BigNumberish, string]
  ): string;
  encodeFunctionData(
    functionFragment: "rejectSlash",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "rewardPerSecond",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "rewarder", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "setVoteRewardCoef",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "slasher", values?: undefined): string;
  encodeFunctionData(functionFragment: "stake", values: [BigNumberish]): string;
  encodeFunctionData(
    functionFragment: "stakeFrozenPeriod",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "token", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "totalAllocPoint",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "updatePool",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "upgrade", values: [string]): string;
  encodeFunctionData(
    functionFragment: "voteRewardCoef",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "voterAllocate",
    values: [string]
  ): string;

  decodeFunctionResult(
    functionFragment: "ACC_PRECISION",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "MAXCOEF", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "candidateInfo",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "claim", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "claimFrozenPeriod",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "downgrade", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "draftSlash", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "election", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "executeSlash",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "gradeOf", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "isCandidateRegistered",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isClaimUnfrozen",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isStakeUnfrozen",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "lastClaimTimestamp",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "lastStakeTimestamp",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "majorCandidateManifests",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "majorCandidates",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "manifestMap",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "minStake", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "pendingCandidateAllocation",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "pendingReward",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "pendingVoterAllocation",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "poolExists", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "poolInfo", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "quit", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "register", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "registerAndStake",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "rejectSlash",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "rewardPerSecond",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "rewarder", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setVoteRewardCoef",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "slasher", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "stake", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "stakeFrozenPeriod",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "token", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "totalAllocPoint",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "updatePool", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "upgrade", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "voteRewardCoef",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "voterAllocate",
    data: BytesLike
  ): Result;

  events: {
    "AddPool(uint8)": EventFragment;
    "CandidateAllocated(address,uint256)": EventFragment;
    "ClaimFrozenPeriodUpdated(uint256)": EventFragment;
    "Claimed(address,address,uint256)": EventFragment;
    "Downgrade(address,uint8,uint8)": EventFragment;
    "DraftSlash(address,uint256)": EventFragment;
    "ElectionUpdated(address)": EventFragment;
    "ExcuteSlash(address,uint256,address[],uint256[],uint256)": EventFragment;
    "IMajorCandidatesUpdated(address)": EventFragment;
    "Initialized(uint8)": EventFragment;
    "MaxCoefUpdated(uint256)": EventFragment;
    "MinStakeUpdated(uint256)": EventFragment;
    "PoolUpdated(uint8)": EventFragment;
    "PrecisionUpdated(uint256)": EventFragment;
    "Quit(uint8,address)": EventFragment;
    "Register(address)": EventFragment;
    "RejectSlash(address,uint256)": EventFragment;
    "RewardPerSecondUpdated(uint256)": EventFragment;
    "RewarderUpdated(address)": EventFragment;
    "SlasherUpdated(address)": EventFragment;
    "Stake(address,address,uint256)": EventFragment;
    "StakeFrozenPeriodUpdated(uint256)": EventFragment;
    "TokenUpdated(address)": EventFragment;
    "Upgrade(address,uint8,uint8)": EventFragment;
    "VoteRewardCoefUpdated(uint256)": EventFragment;
    "VoterAllocated(address,uint256)": EventFragment;
    "Withdrawn(address,address,uint256)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "AddPool"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "CandidateAllocated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ClaimFrozenPeriodUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Claimed"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Downgrade"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "DraftSlash"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ElectionUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ExcuteSlash"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "IMajorCandidatesUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "MaxCoefUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "MinStakeUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "PoolUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "PrecisionUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Quit"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Register"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RejectSlash"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RewardPerSecondUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RewarderUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SlasherUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Stake"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "StakeFrozenPeriodUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "TokenUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Upgrade"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "VoteRewardCoefUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "VoterAllocated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Withdrawn"): EventFragment;
}

export type AddPoolEvent = TypedEvent<[number] & { grade: number }>;

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

export type ClaimFrozenPeriodUpdatedEvent = TypedEvent<
  [BigNumber] & { period: BigNumber }
>;

export type ClaimedEvent = TypedEvent<
  [string, string, BigNumber] & {
    candidate: string;
    to: string;
    pending: BigNumber;
  }
>;

export type DowngradeEvent = TypedEvent<
  [string, number, number] & {
    candidate: string;
    fromGrade: number;
    toGrade: number;
  }
>;

export type DraftSlashEvent = TypedEvent<
  [string, BigNumber] & { candidate: string; pendingSlash: BigNumber }
>;

export type ElectionUpdatedEvent = TypedEvent<[string] & { election: string }>;

export type ExcuteSlashEvent = TypedEvent<
  [string, BigNumber, string[], BigNumber[], BigNumber] & {
    candidate: string;
    pendingSlash: BigNumber;
    beneficiaries: string[];
    amounts: BigNumber[];
    burned: BigNumber;
  }
>;

export type IMajorCandidatesUpdatedEvent = TypedEvent<
  [string] & { majorCandidates: string }
>;

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

export type MaxCoefUpdatedEvent = TypedEvent<
  [BigNumber] & { maxCoef: BigNumber }
>;

export type MinStakeUpdatedEvent = TypedEvent<
  [BigNumber] & { amount: BigNumber }
>;

export type PoolUpdatedEvent = TypedEvent<[number] & { grade: number }>;

export type PrecisionUpdatedEvent = TypedEvent<
  [BigNumber] & { precision: BigNumber }
>;

export type QuitEvent = TypedEvent<
  [number, string] & { grade: number; candidate: string }
>;

export type RegisterEvent = TypedEvent<[string] & { candidate: string }>;

export type RejectSlashEvent = TypedEvent<
  [string, BigNumber] & { candidate: string; pendingSlash: BigNumber }
>;

export type RewardPerSecondUpdatedEvent = TypedEvent<
  [BigNumber] & { rewardPerSecond: BigNumber }
>;

export type RewarderUpdatedEvent = TypedEvent<[string] & { rewarder: string }>;

export type SlasherUpdatedEvent = TypedEvent<[string] & { slasher: string }>;

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

export type StakeFrozenPeriodUpdatedEvent = TypedEvent<
  [BigNumber] & { period: BigNumber }
>;

export type TokenUpdatedEvent = TypedEvent<[string] & { token: string }>;

export type UpgradeEvent = TypedEvent<
  [string, number, number] & {
    candidate: string;
    fromGrade: number;
    toGrade: number;
  }
>;

export type VoteRewardCoefUpdatedEvent = TypedEvent<
  [BigNumber] & { coef: BigNumber }
>;

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

export type WithdrawnEvent = TypedEvent<
  [string, string, BigNumber] & {
    candidate: string;
    to: string;
    amount: BigNumber;
  }
>;

export class Stake 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: StakeInterface;

  functions: {
    ACC_PRECISION(overrides?: CallOverrides): Promise<[BigNumber]>;

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

    candidateInfo(
      candidate: string,
      overrides?: CallOverrides
    ): Promise<
      [
        [number, BigNumber, BigNumber, BigNumber, string] & {
          grade: number;
          amount: BigNumber;
          rewardDebt: BigNumber;
          allocation: BigNumber;
          manifest: string;
        }
      ]
    >;

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

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

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

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

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

    executeSlash(
      _candidate: string,
      slash: BigNumberish,
      beneficiaries: string[],
      amounts: BigNumberish[],
      burned: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    gradeOf(candidate: string, overrides?: CallOverrides): Promise<[number]>;

    initialize(
      token: string,
      rewarder: string,
      _election: string,
      _majorCandidates: string,
      _slasher: string,
      _stakeFrozenPeriod: BigNumberish,
      _minStake: BigNumberish,
      rewardPerSecond: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    isCandidateRegistered(
      candidate: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    isClaimUnfrozen(
      candidate: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    isStakeUnfrozen(
      candidate: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    lastClaimTimestamp(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    lastStakeTimestamp(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    majorCandidateManifests(
      overrides?: CallOverrides
    ): Promise<[string[]] & { manifests: string[] }>;

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

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

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

    pendingCandidateAllocation(
      _candidate: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { pendingAllocation: BigNumber }>;

    pendingReward(
      _candidate: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { pending: BigNumber }>;

    pendingVoterAllocation(
      _candidate: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { pendingAllocation: BigNumber }>;

    poolExists(
      grade: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    poolInfo(
      grade: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [
        [BigNumber, BigNumber, BigNumber] & {
          accPerShare: BigNumber;
          lastRewardTime: BigNumber;
          allocPoint: BigNumber;
        }
      ]
    >;

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

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

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

    rejectSlash(
      _candidate: string,
      pendingSlash: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

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

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

    voteRewardCoef(
      candidate: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

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

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

  candidateInfo(
    candidate: string,
    overrides?: CallOverrides
  ): Promise<
    [number, BigNumber, BigNumber, BigNumber, string] & {
      grade: number;
      amount: BigNumber;
      rewardDebt: BigNumber;
      allocation: BigNumber;
      manifest: string;
    }
  >;

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

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

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

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

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

  executeSlash(
    _candidate: string,
    slash: BigNumberish,
    beneficiaries: string[],
    amounts: BigNumberish[],
    burned: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  gradeOf(candidate: string, overrides?: CallOverrides): Promise<number>;

  initialize(
    token: string,
    rewarder: string,
    _election: string,
    _majorCandidates: string,
    _slasher: string,
    _stakeFrozenPeriod: BigNumberish,
    _minStake: BigNumberish,
    rewardPerSecond: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  isCandidateRegistered(
    candidate: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

  isClaimUnfrozen(
    candidate: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

  isStakeUnfrozen(
    candidate: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

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

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

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

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

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

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

  pendingCandidateAllocation(
    _candidate: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  pendingReward(
    _candidate: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  pendingVoterAllocation(
    _candidate: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  poolExists(grade: BigNumberish, overrides?: CallOverrides): Promise<boolean>;

  poolInfo(
    grade: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber, BigNumber] & {
      accPerShare: BigNumber;
      lastRewardTime: BigNumber;
      allocPoint: BigNumber;
    }
  >;

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

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

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

  rejectSlash(
    _candidate: string,
    pendingSlash: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

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

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

  voteRewardCoef(
    candidate: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

  callStatic: {
    ACC_PRECISION(overrides?: CallOverrides): Promise<BigNumber>;

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

    candidateInfo(
      candidate: string,
      overrides?: CallOverrides
    ): Promise<
      [number, BigNumber, BigNumber, BigNumber, string] & {
        grade: number;
        amount: BigNumber;
        rewardDebt: BigNumber;
        allocation: BigNumber;
        manifest: string;
      }
    >;

    claim(to: string, overrides?: CallOverrides): Promise<void>;

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

    downgrade(candidate: string, overrides?: CallOverrides): Promise<void>;

    draftSlash(
      _candidate: string,
      amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    executeSlash(
      _candidate: string,
      slash: BigNumberish,
      beneficiaries: string[],
      amounts: BigNumberish[],
      burned: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    gradeOf(candidate: string, overrides?: CallOverrides): Promise<number>;

    initialize(
      token: string,
      rewarder: string,
      _election: string,
      _majorCandidates: string,
      _slasher: string,
      _stakeFrozenPeriod: BigNumberish,
      _minStake: BigNumberish,
      rewardPerSecond: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    isCandidateRegistered(
      candidate: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

    isClaimUnfrozen(
      candidate: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

    isStakeUnfrozen(
      candidate: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

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

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

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

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

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

    pendingCandidateAllocation(
      _candidate: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    pendingReward(
      _candidate: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    pendingVoterAllocation(
      _candidate: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    poolExists(
      grade: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    poolInfo(
      grade: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber] & {
        accPerShare: BigNumber;
        lastRewardTime: BigNumber;
        allocPoint: BigNumber;
      }
    >;

    quit(to: string, overrides?: CallOverrides): Promise<void>;

    register(manifest: string, overrides?: CallOverrides): Promise<void>;

    registerAndStake(
      amount: BigNumberish,
      manifest: string,
      overrides?: CallOverrides
    ): Promise<void>;

    rejectSlash(
      _candidate: string,
      pendingSlash: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    setVoteRewardCoef(
      coef: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

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

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

    updatePool(
      grade: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber] & {
        accPerShare: BigNumber;
        lastRewardTime: BigNumber;
        allocPoint: BigNumber;
      }
    >;

    upgrade(candidate: string, overrides?: CallOverrides): Promise<void>;

    voteRewardCoef(
      candidate: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    voterAllocate(candidate: string, overrides?: CallOverrides): Promise<void>;
  };

  filters: {
    "AddPool(uint8)"(
      grade?: null
    ): TypedEventFilter<[number], { grade: number }>;

    AddPool(grade?: null): TypedEventFilter<[number], { grade: number }>;

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

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

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

    ClaimFrozenPeriodUpdated(
      period?: null
    ): TypedEventFilter<[BigNumber], { period: BigNumber }>;

    "Claimed(address,address,uint256)"(
      candidate?: null,
      to?: null,
      pending?: null
    ): TypedEventFilter<
      [string, string, BigNumber],
      { candidate: string; to: string; pending: BigNumber }
    >;

    Claimed(
      candidate?: null,
      to?: null,
      pending?: null
    ): TypedEventFilter<
      [string, string, BigNumber],
      { candidate: string; to: string; pending: BigNumber }
    >;

    "Downgrade(address,uint8,uint8)"(
      candidate?: null,
      fromGrade?: null,
      toGrade?: null
    ): TypedEventFilter<
      [string, number, number],
      { candidate: string; fromGrade: number; toGrade: number }
    >;

    Downgrade(
      candidate?: null,
      fromGrade?: null,
      toGrade?: null
    ): TypedEventFilter<
      [string, number, number],
      { candidate: string; fromGrade: number; toGrade: number }
    >;

    "DraftSlash(address,uint256)"(
      candidate?: null,
      pendingSlash?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { candidate: string; pendingSlash: BigNumber }
    >;

    DraftSlash(
      candidate?: null,
      pendingSlash?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { candidate: string; pendingSlash: BigNumber }
    >;

    "ElectionUpdated(address)"(
      election?: null
    ): TypedEventFilter<[string], { election: string }>;

    ElectionUpdated(
      election?: null
    ): TypedEventFilter<[string], { election: string }>;

    "ExcuteSlash(address,uint256,address[],uint256[],uint256)"(
      candidate?: null,
      pendingSlash?: null,
      beneficiaries?: null,
      amounts?: null,
      burned?: null
    ): TypedEventFilter<
      [string, BigNumber, string[], BigNumber[], BigNumber],
      {
        candidate: string;
        pendingSlash: BigNumber;
        beneficiaries: string[];
        amounts: BigNumber[];
        burned: BigNumber;
      }
    >;

    ExcuteSlash(
      candidate?: null,
      pendingSlash?: null,
      beneficiaries?: null,
      amounts?: null,
      burned?: null
    ): TypedEventFilter<
      [string, BigNumber, string[], BigNumber[], BigNumber],
      {
        candidate: string;
        pendingSlash: BigNumber;
        beneficiaries: string[];
        amounts: BigNumber[];
        burned: BigNumber;
      }
    >;

    "IMajorCandidatesUpdated(address)"(
      majorCandidates?: null
    ): TypedEventFilter<[string], { majorCandidates: string }>;

    IMajorCandidatesUpdated(
      majorCandidates?: null
    ): TypedEventFilter<[string], { majorCandidates: string }>;

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

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

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

    MaxCoefUpdated(
      maxCoef?: null
    ): TypedEventFilter<[BigNumber], { maxCoef: BigNumber }>;

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

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

    "PoolUpdated(uint8)"(
      grade?: null
    ): TypedEventFilter<[number], { grade: number }>;

    PoolUpdated(grade?: null): TypedEventFilter<[number], { grade: number }>;

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

    PrecisionUpdated(
      precision?: null
    ): TypedEventFilter<[BigNumber], { precision: BigNumber }>;

    "Quit(uint8,address)"(
      grade?: null,
      candidate?: null
    ): TypedEventFilter<[number, string], { grade: number; candidate: string }>;

    Quit(
      grade?: null,
      candidate?: null
    ): TypedEventFilter<[number, string], { grade: number; candidate: string }>;

    "Register(address)"(
      candidate?: null
    ): TypedEventFilter<[string], { candidate: string }>;

    Register(
      candidate?: null
    ): TypedEventFilter<[string], { candidate: string }>;

    "RejectSlash(address,uint256)"(
      candidate?: null,
      pendingSlash?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { candidate: string; pendingSlash: BigNumber }
    >;

    RejectSlash(
      candidate?: null,
      pendingSlash?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { candidate: string; pendingSlash: BigNumber }
    >;

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

    RewardPerSecondUpdated(
      rewardPerSecond?: null
    ): TypedEventFilter<[BigNumber], { rewardPerSecond: BigNumber }>;

    "RewarderUpdated(address)"(
      rewarder?: null
    ): TypedEventFilter<[string], { rewarder: string }>;

    RewarderUpdated(
      rewarder?: null
    ): TypedEventFilter<[string], { rewarder: string }>;

    "SlasherUpdated(address)"(
      slasher?: null
    ): TypedEventFilter<[string], { slasher: string }>;

    SlasherUpdated(
      slasher?: null
    ): TypedEventFilter<[string], { slasher: string }>;

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

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

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

    StakeFrozenPeriodUpdated(
      period?: null
    ): TypedEventFilter<[BigNumber], { period: BigNumber }>;

    "TokenUpdated(address)"(
      token?: null
    ): TypedEventFilter<[string], { token: string }>;

    TokenUpdated(token?: null): TypedEventFilter<[string], { token: string }>;

    "Upgrade(address,uint8,uint8)"(
      candidate?: null,
      fromGrade?: null,
      toGrade?: null
    ): TypedEventFilter<
      [string, number, number],
      { candidate: string; fromGrade: number; toGrade: number }
    >;

    Upgrade(
      candidate?: null,
      fromGrade?: null,
      toGrade?: null
    ): TypedEventFilter<
      [string, number, number],
      { candidate: string; fromGrade: number; toGrade: number }
    >;

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

    VoteRewardCoefUpdated(
      coef?: null
    ): TypedEventFilter<[BigNumber], { coef: BigNumber }>;

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

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

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

    Withdrawn(
      candidate?: null,
      to?: null,
      amount?: null
    ): TypedEventFilter<
      [string, string, BigNumber],
      { candidate: string; to: string; amount: BigNumber }
    >;
  };

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

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

    candidateInfo(
      candidate: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

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

    executeSlash(
      _candidate: string,
      slash: BigNumberish,
      beneficiaries: string[],
      amounts: BigNumberish[],
      burned: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    gradeOf(candidate: string, overrides?: CallOverrides): Promise<BigNumber>;

    initialize(
      token: string,
      rewarder: string,
      _election: string,
      _majorCandidates: string,
      _slasher: string,
      _stakeFrozenPeriod: BigNumberish,
      _minStake: BigNumberish,
      rewardPerSecond: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    isCandidateRegistered(
      candidate: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    isClaimUnfrozen(
      candidate: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    isStakeUnfrozen(
      candidate: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

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

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

    pendingCandidateAllocation(
      _candidate: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    pendingReward(
      _candidate: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    pendingVoterAllocation(
      _candidate: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    poolExists(
      grade: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    poolInfo(
      grade: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

    rejectSlash(
      _candidate: string,
      pendingSlash: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

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

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

    voteRewardCoef(
      candidate: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

    candidateInfo(
      candidate: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

    executeSlash(
      _candidate: string,
      slash: BigNumberish,
      beneficiaries: string[],
      amounts: BigNumberish[],
      burned: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    gradeOf(
      candidate: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    initialize(
      token: string,
      rewarder: string,
      _election: string,
      _majorCandidates: string,
      _slasher: string,
      _stakeFrozenPeriod: BigNumberish,
      _minStake: BigNumberish,
      rewardPerSecond: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    isCandidateRegistered(
      candidate: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    isClaimUnfrozen(
      candidate: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    isStakeUnfrozen(
      candidate: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

    pendingCandidateAllocation(
      _candidate: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    pendingReward(
      _candidate: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    pendingVoterAllocation(
      _candidate: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    poolExists(
      grade: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    poolInfo(
      grade: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

    rejectSlash(
      _candidate: string,
      pendingSlash: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

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

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

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

    voteRewardCoef(
      candidate: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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