/* Autogenerated file. Do not edit manually. */
/* tslint:disable */
/* eslint-disable */
import type {
  BaseContract,
  BigNumber,
  BigNumberish,
  BytesLike,
  CallOverrides,
  ContractTransaction,
  Overrides,
  PopulatedTransaction,
  Signer,
  utils,
} from "ethers";
import type {
  FunctionFragment,
  Result,
  EventFragment,
} from "@ethersproject/abi";
import type { Listener, Provider } from "@ethersproject/providers";
import type {
  TypedEventFilter,
  TypedEvent,
  TypedListener,
  OnEvent,
} from "./common.js";

export declare namespace Staking {
  export type AccountSnapshotStruct = {
    interval: BigNumberish;
    votingPower: BigNumberish;
  };

  export type AccountSnapshotStructOutput = [BigNumber, BigNumber] & {
    interval: BigNumber;
    votingPower: BigNumber;
  };

  export type GlobalsSnapshotStruct = {
    interval: BigNumberish;
    totalVotingPower: BigNumberish;
    totalStaked: BigNumberish;
  };

  export type GlobalsSnapshotStructOutput = [
    BigNumber,
    BigNumber,
    BigNumber
  ] & {
    interval: BigNumber;
    totalVotingPower: BigNumber;
    totalStaked: BigNumber;
  };
}

export interface RailgunGovernanceInterface extends utils.Interface {
  functions: {
    "DEPLOY_TIME()": FunctionFragment;
    "SNAPSHOT_INTERVAL()": FunctionFragment;
    "STAKE_LOCKTIME()": FunctionFragment;
    "accountSnapshot(address,uint256)": FunctionFragment;
    "accountSnapshotAt(address,uint256,uint256)": FunctionFragment;
    "accountSnapshotLength(address)": FunctionFragment;
    "claim(uint256)": FunctionFragment;
    "currentInterval()": FunctionFragment;
    "delegate(uint256,address)": FunctionFragment;
    "globalsSnapshot(uint256)": FunctionFragment;
    "globalsSnapshotAt(uint256,uint256)": FunctionFragment;
    "globalsSnapshotLength()": FunctionFragment;
    "intervalAtTime(uint256)": FunctionFragment;
    "latestAccountSnapshotInterval(address)": FunctionFragment;
    "latestGlobalsSnapshotInterval()": FunctionFragment;
    "stake(uint256)": FunctionFragment;
    "stakes(address,uint256)": FunctionFragment;
    "stakesLength(address)": FunctionFragment;
    "stakingToken()": FunctionFragment;
    "totalStaked()": FunctionFragment;
    "totalVotingPower()": FunctionFragment;
    "undelegate(uint256)": FunctionFragment;
    "unlock(uint256)": FunctionFragment;
    "votingPower(address)": FunctionFragment;
  };

  getFunction(
    nameOrSignatureOrTopic:
      | "DEPLOY_TIME"
      | "SNAPSHOT_INTERVAL"
      | "STAKE_LOCKTIME"
      | "accountSnapshot"
      | "accountSnapshotAt"
      | "accountSnapshotLength"
      | "claim"
      | "currentInterval"
      | "delegate"
      | "globalsSnapshot"
      | "globalsSnapshotAt"
      | "globalsSnapshotLength"
      | "intervalAtTime"
      | "latestAccountSnapshotInterval"
      | "latestGlobalsSnapshotInterval"
      | "stake"
      | "stakes"
      | "stakesLength"
      | "stakingToken"
      | "totalStaked"
      | "totalVotingPower"
      | "undelegate"
      | "unlock"
      | "votingPower"
  ): FunctionFragment;

  encodeFunctionData(
    functionFragment: "DEPLOY_TIME",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "SNAPSHOT_INTERVAL",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "STAKE_LOCKTIME",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "accountSnapshot",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "accountSnapshotAt",
    values: [string, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "accountSnapshotLength",
    values: [string]
  ): string;
  encodeFunctionData(functionFragment: "claim", values: [BigNumberish]): string;
  encodeFunctionData(
    functionFragment: "currentInterval",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "delegate",
    values: [BigNumberish, string]
  ): string;
  encodeFunctionData(
    functionFragment: "globalsSnapshot",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "globalsSnapshotAt",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "globalsSnapshotLength",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "intervalAtTime",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "latestAccountSnapshotInterval",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "latestGlobalsSnapshotInterval",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "stake", values: [BigNumberish]): string;
  encodeFunctionData(
    functionFragment: "stakes",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "stakesLength",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "stakingToken",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "totalStaked",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "totalVotingPower",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "undelegate",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "unlock",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "votingPower", values: [string]): string;

  decodeFunctionResult(
    functionFragment: "DEPLOY_TIME",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "SNAPSHOT_INTERVAL",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "STAKE_LOCKTIME",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "accountSnapshot",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "accountSnapshotAt",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "accountSnapshotLength",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "claim", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "currentInterval",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "delegate", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "globalsSnapshot",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "globalsSnapshotAt",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "globalsSnapshotLength",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "intervalAtTime",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "latestAccountSnapshotInterval",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "latestGlobalsSnapshotInterval",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "stake", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "stakes", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "stakesLength",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "stakingToken",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "totalStaked",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "totalVotingPower",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "undelegate", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "unlock", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "votingPower",
    data: BytesLike
  ): Result;

  events: {
    "Claim(address,uint256)": EventFragment;
    "Delegate(address,address,address,uint256,uint256)": EventFragment;
    "Stake(address,uint256,uint256)": EventFragment;
    "Unlock(address,uint256)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "Claim"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Delegate"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Stake"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Unlock"): EventFragment;
}

export interface ClaimEventObject {
  account: string;
  stakeID: BigNumber;
}
export type ClaimEvent = TypedEvent<[string, BigNumber], ClaimEventObject>;

export type ClaimEventFilter = TypedEventFilter<ClaimEvent>;

export interface DelegateEventObject {
  owner: string;
  _from: string;
  to: string;
  stakeID: BigNumber;
  amount: BigNumber;
}
export type DelegateEvent = TypedEvent<
  [string, string, string, BigNumber, BigNumber],
  DelegateEventObject
>;

export type DelegateEventFilter = TypedEventFilter<DelegateEvent>;

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

export type StakeEventFilter = TypedEventFilter<StakeEvent>;

export interface UnlockEventObject {
  account: string;
  stakeID: BigNumber;
}
export type UnlockEvent = TypedEvent<[string, BigNumber], UnlockEventObject>;

export type UnlockEventFilter = TypedEventFilter<UnlockEvent>;

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

  interface: RailgunGovernanceInterface;

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

  listeners<TEvent extends TypedEvent>(
    eventFilter?: TypedEventFilter<TEvent>
  ): Array<TypedListener<TEvent>>;
  listeners(eventName?: string): Array<Listener>;
  removeAllListeners<TEvent extends TypedEvent>(
    eventFilter: TypedEventFilter<TEvent>
  ): this;
  removeAllListeners(eventName?: string): this;
  off: OnEvent<this>;
  on: OnEvent<this>;
  once: OnEvent<this>;
  removeListener: OnEvent<this>;

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

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

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

    accountSnapshot(
      _account: string,
      _index: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[Staking.AccountSnapshotStructOutput]>;

    accountSnapshotAt(
      _account: string,
      _interval: BigNumberish,
      _hint: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[Staking.AccountSnapshotStructOutput]>;

    accountSnapshotLength(
      _account: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

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

    delegate(
      _stakeID: BigNumberish,
      _to: string,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    globalsSnapshot(
      _index: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[Staking.GlobalsSnapshotStructOutput]>;

    globalsSnapshotAt(
      _interval: BigNumberish,
      _hint: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[Staking.GlobalsSnapshotStructOutput]>;

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

    intervalAtTime(
      _time: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    latestAccountSnapshotInterval(
      _account: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

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

    stakes(
      arg0: string,
      arg1: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [string, BigNumber, BigNumber, BigNumber, BigNumber] & {
        delegate: string;
        amount: BigNumber;
        staketime: BigNumber;
        locktime: BigNumber;
        claimedTime: BigNumber;
      }
    >;

    stakesLength(
      _account: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

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

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

    undelegate(
      _stakeID: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    unlock(
      _stakeID: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

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

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

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

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

  accountSnapshot(
    _account: string,
    _index: BigNumberish,
    overrides?: CallOverrides
  ): Promise<Staking.AccountSnapshotStructOutput>;

  accountSnapshotAt(
    _account: string,
    _interval: BigNumberish,
    _hint: BigNumberish,
    overrides?: CallOverrides
  ): Promise<Staking.AccountSnapshotStructOutput>;

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

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

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

  delegate(
    _stakeID: BigNumberish,
    _to: string,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  globalsSnapshot(
    _index: BigNumberish,
    overrides?: CallOverrides
  ): Promise<Staking.GlobalsSnapshotStructOutput>;

  globalsSnapshotAt(
    _interval: BigNumberish,
    _hint: BigNumberish,
    overrides?: CallOverrides
  ): Promise<Staking.GlobalsSnapshotStructOutput>;

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

  intervalAtTime(
    _time: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

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

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

  stakes(
    arg0: string,
    arg1: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    [string, BigNumber, BigNumber, BigNumber, BigNumber] & {
      delegate: string;
      amount: BigNumber;
      staketime: BigNumber;
      locktime: BigNumber;
      claimedTime: BigNumber;
    }
  >;

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

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

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

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

  undelegate(
    _stakeID: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  unlock(
    _stakeID: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

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

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

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

    accountSnapshot(
      _account: string,
      _index: BigNumberish,
      overrides?: CallOverrides
    ): Promise<Staking.AccountSnapshotStructOutput>;

    accountSnapshotAt(
      _account: string,
      _interval: BigNumberish,
      _hint: BigNumberish,
      overrides?: CallOverrides
    ): Promise<Staking.AccountSnapshotStructOutput>;

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

    claim(_stakeID: BigNumberish, overrides?: CallOverrides): Promise<void>;

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

    delegate(
      _stakeID: BigNumberish,
      _to: string,
      overrides?: CallOverrides
    ): Promise<void>;

    globalsSnapshot(
      _index: BigNumberish,
      overrides?: CallOverrides
    ): Promise<Staking.GlobalsSnapshotStructOutput>;

    globalsSnapshotAt(
      _interval: BigNumberish,
      _hint: BigNumberish,
      overrides?: CallOverrides
    ): Promise<Staking.GlobalsSnapshotStructOutput>;

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

    intervalAtTime(
      _time: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    stake(_amount: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;

    stakes(
      arg0: string,
      arg1: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [string, BigNumber, BigNumber, BigNumber, BigNumber] & {
        delegate: string;
        amount: BigNumber;
        staketime: BigNumber;
        locktime: BigNumber;
        claimedTime: BigNumber;
      }
    >;

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

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

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

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

    undelegate(
      _stakeID: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    unlock(_stakeID: BigNumberish, overrides?: CallOverrides): Promise<void>;

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

  filters: {
    "Claim(address,uint256)"(
      account?: string | null,
      stakeID?: BigNumberish | null
    ): ClaimEventFilter;
    Claim(
      account?: string | null,
      stakeID?: BigNumberish | null
    ): ClaimEventFilter;

    "Delegate(address,address,address,uint256,uint256)"(
      owner?: string | null,
      _from?: string | null,
      to?: string | null,
      stakeID?: null,
      amount?: null
    ): DelegateEventFilter;
    Delegate(
      owner?: string | null,
      _from?: string | null,
      to?: string | null,
      stakeID?: null,
      amount?: null
    ): DelegateEventFilter;

    "Stake(address,uint256,uint256)"(
      account?: string | null,
      stakeID?: BigNumberish | null,
      amount?: null
    ): StakeEventFilter;
    Stake(
      account?: string | null,
      stakeID?: BigNumberish | null,
      amount?: null
    ): StakeEventFilter;

    "Unlock(address,uint256)"(
      account?: string | null,
      stakeID?: BigNumberish | null
    ): UnlockEventFilter;
    Unlock(
      account?: string | null,
      stakeID?: BigNumberish | null
    ): UnlockEventFilter;
  };

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

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

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

    accountSnapshot(
      _account: string,
      _index: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    accountSnapshotAt(
      _account: string,
      _interval: BigNumberish,
      _hint: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

    delegate(
      _stakeID: BigNumberish,
      _to: string,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    globalsSnapshot(
      _index: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    globalsSnapshotAt(
      _interval: BigNumberish,
      _hint: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    intervalAtTime(
      _time: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

    undelegate(
      _stakeID: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    unlock(
      _stakeID: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

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

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

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

    accountSnapshot(
      _account: string,
      _index: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    accountSnapshotAt(
      _account: string,
      _interval: BigNumberish,
      _hint: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

    delegate(
      _stakeID: BigNumberish,
      _to: string,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    globalsSnapshot(
      _index: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    globalsSnapshotAt(
      _interval: BigNumberish,
      _hint: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    intervalAtTime(
      _time: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

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

    undelegate(
      _stakeID: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    unlock(
      _stakeID: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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