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

interface StakeManagerAbiInterface extends ethers.utils.Interface {
  functions: {
    "CHECKPOINT_REWARD()": FunctionFragment;
    "NFTContract()": FunctionFragment;
    "NFTCounter()": FunctionFragment;
    "WITHDRAWAL_DELAY()": FunctionFragment;
    "accountStateRoot()": FunctionFragment;
    "auctionPeriod()": FunctionFragment;
    "changeRootChain(address)": FunctionFragment;
    "checkPointBlockInterval()": FunctionFragment;
    "checkSignatures(uint256,bytes32,bytes32,address,uint256[3][])": FunctionFragment;
    "checkpointRewardDelta()": FunctionFragment;
    "claimFee(uint256,uint256,bytes)": FunctionFragment;
    "confirmAuctionBid(uint256,uint256)": FunctionFragment;
    "currentEpoch()": FunctionFragment;
    "currentValidatorSetSize()": FunctionFragment;
    "currentValidatorSetTotalStake()": FunctionFragment;
    "decreaseValidatorDelegatedAmount(uint256,uint256)": FunctionFragment;
    "delegatedAmount(uint256)": FunctionFragment;
    "delegationDeposit(uint256,uint256,address)": FunctionFragment;
    "delegationEnabled()": FunctionFragment;
    "delegatorsReward(uint256)": FunctionFragment;
    "dethroneAndStake(address,uint256,uint256,uint256,bool,bytes)": FunctionFragment;
    "drain(address,uint256)": FunctionFragment;
    "drainValidatorShares(uint256,address,address,uint256)": FunctionFragment;
    "dynasty()": FunctionFragment;
    "epoch()": FunctionFragment;
    "eventsHub()": FunctionFragment;
    "extensionCode()": FunctionFragment;
    "forceUnstake(uint256)": FunctionFragment;
    "getRegistry()": FunctionFragment;
    "getValidatorContract(uint256)": FunctionFragment;
    "getValidatorId(address)": FunctionFragment;
    "governance()": FunctionFragment;
    "initialize(address,address,address,address,address,address,address,address,address)": FunctionFragment;
    "insertSigners(address[])": FunctionFragment;
    "isOwner()": FunctionFragment;
    "isValidator(uint256)": FunctionFragment;
    "latestSignerUpdateEpoch(uint256)": FunctionFragment;
    "lock()": FunctionFragment;
    "locked()": FunctionFragment;
    "logger()": FunctionFragment;
    "maxRewardedCheckpoints()": FunctionFragment;
    "migrateDelegation(uint256,uint256,uint256)": FunctionFragment;
    "migrateValidatorsData(uint256,uint256)": FunctionFragment;
    "minDeposit()": FunctionFragment;
    "minHeimdallFee()": FunctionFragment;
    "owner()": FunctionFragment;
    "ownerOf(uint256)": FunctionFragment;
    "prevBlockInterval()": FunctionFragment;
    "proposerBonus()": FunctionFragment;
    "registry()": FunctionFragment;
    "reinitialize(address,address,address,address)": FunctionFragment;
    "renounceOwnership()": FunctionFragment;
    "replacementCoolDown()": FunctionFragment;
    "restake(uint256,uint256,bool)": FunctionFragment;
    "rewardDecreasePerCheckpoint()": FunctionFragment;
    "rewardPerStake()": FunctionFragment;
    "rootChain()": FunctionFragment;
    "setCurrentEpoch(uint256)": FunctionFragment;
    "setDelegationEnabled(bool)": FunctionFragment;
    "setStakingToken(address)": FunctionFragment;
    "signerToValidator(address)": FunctionFragment;
    "signerUpdateLimit()": FunctionFragment;
    "signers(uint256)": FunctionFragment;
    "slash(bytes)": FunctionFragment;
    "stakeFor(address,uint256,uint256,bool,bytes)": FunctionFragment;
    "startAuction(uint256,uint256,bool,bytes)": FunctionFragment;
    "stopAuctions(uint256)": FunctionFragment;
    "token()": FunctionFragment;
    "topUpForFee(address,uint256)": FunctionFragment;
    "totalHeimdallFee()": FunctionFragment;
    "totalRewards()": FunctionFragment;
    "totalRewardsLiquidated()": FunctionFragment;
    "totalStaked()": FunctionFragment;
    "totalStakedFor(address)": FunctionFragment;
    "transferFunds(uint256,uint256,address)": FunctionFragment;
    "transferOwnership(address)": FunctionFragment;
    "unjail(uint256)": FunctionFragment;
    "unlock()": FunctionFragment;
    "unstake(uint256)": FunctionFragment;
    "unstakeClaim(uint256)": FunctionFragment;
    "updateCheckPointBlockInterval(uint256)": FunctionFragment;
    "updateCheckpointReward(uint256)": FunctionFragment;
    "updateCheckpointRewardParams(uint256,uint256,uint256)": FunctionFragment;
    "updateCommissionRate(uint256,uint256)": FunctionFragment;
    "updateDynastyValue(uint256)": FunctionFragment;
    "updateMinAmounts(uint256,uint256)": FunctionFragment;
    "updateProposerBonus(uint256)": FunctionFragment;
    "updateSigner(uint256,bytes)": FunctionFragment;
    "updateSignerUpdateLimit(uint256)": FunctionFragment;
    "updateValidatorContractAddress(uint256,address)": FunctionFragment;
    "updateValidatorDelegation(bool)": FunctionFragment;
    "updateValidatorState(uint256,int256)": FunctionFragment;
    "updateValidatorThreshold(uint256)": FunctionFragment;
    "userFeeExit(address)": FunctionFragment;
    "validatorAuction(uint256)": FunctionFragment;
    "validatorReward(uint256)": FunctionFragment;
    "validatorShareFactory()": FunctionFragment;
    "validatorStake(uint256)": FunctionFragment;
    "validatorState()": FunctionFragment;
    "validatorStateChanges(uint256)": FunctionFragment;
    "validatorThreshold()": FunctionFragment;
    "validators(uint256)": FunctionFragment;
    "withdrawDelegatorsReward(uint256)": FunctionFragment;
    "withdrawRewards(uint256)": FunctionFragment;
    "withdrawalDelay()": FunctionFragment;
  };

  encodeFunctionData(
    functionFragment: "CHECKPOINT_REWARD",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "NFTContract",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "NFTCounter",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "WITHDRAWAL_DELAY",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "accountStateRoot",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "auctionPeriod",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "changeRootChain",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "checkPointBlockInterval",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "checkSignatures",
    values: [
      BigNumberish,
      BytesLike,
      BytesLike,
      string,
      [BigNumberish, BigNumberish, BigNumberish][]
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "checkpointRewardDelta",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "claimFee",
    values: [BigNumberish, BigNumberish, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "confirmAuctionBid",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "currentEpoch",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "currentValidatorSetSize",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "currentValidatorSetTotalStake",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "decreaseValidatorDelegatedAmount",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "delegatedAmount",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "delegationDeposit",
    values: [BigNumberish, BigNumberish, string]
  ): string;
  encodeFunctionData(
    functionFragment: "delegationEnabled",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "delegatorsReward",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "dethroneAndStake",
    values: [
      string,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      boolean,
      BytesLike
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "drain",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "drainValidatorShares",
    values: [BigNumberish, string, string, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "dynasty", values?: undefined): string;
  encodeFunctionData(functionFragment: "epoch", values?: undefined): string;
  encodeFunctionData(functionFragment: "eventsHub", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "extensionCode",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "forceUnstake",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getRegistry",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getValidatorContract",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getValidatorId",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "governance",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "initialize",
    values: [
      string,
      string,
      string,
      string,
      string,
      string,
      string,
      string,
      string
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "insertSigners",
    values: [string[]]
  ): string;
  encodeFunctionData(functionFragment: "isOwner", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "isValidator",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "latestSignerUpdateEpoch",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "lock", values?: undefined): string;
  encodeFunctionData(functionFragment: "locked", values?: undefined): string;
  encodeFunctionData(functionFragment: "logger", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "maxRewardedCheckpoints",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "migrateDelegation",
    values: [BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "migrateValidatorsData",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "minDeposit",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "minHeimdallFee",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "ownerOf",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "prevBlockInterval",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "proposerBonus",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "registry", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "reinitialize",
    values: [string, string, string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "renounceOwnership",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "replacementCoolDown",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "restake",
    values: [BigNumberish, BigNumberish, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "rewardDecreasePerCheckpoint",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "rewardPerStake",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "rootChain", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "setCurrentEpoch",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setDelegationEnabled",
    values: [boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "setStakingToken",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "signerToValidator",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "signerUpdateLimit",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "signers",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "slash", values: [BytesLike]): string;
  encodeFunctionData(
    functionFragment: "stakeFor",
    values: [string, BigNumberish, BigNumberish, boolean, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "startAuction",
    values: [BigNumberish, BigNumberish, boolean, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "stopAuctions",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "token", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "topUpForFee",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "totalHeimdallFee",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "totalRewards",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "totalRewardsLiquidated",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "totalStaked",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "totalStakedFor",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "transferFunds",
    values: [BigNumberish, BigNumberish, string]
  ): string;
  encodeFunctionData(
    functionFragment: "transferOwnership",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "unjail",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "unlock", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "unstake",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "unstakeClaim",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "updateCheckPointBlockInterval",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "updateCheckpointReward",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "updateCheckpointRewardParams",
    values: [BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "updateCommissionRate",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "updateDynastyValue",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "updateMinAmounts",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "updateProposerBonus",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "updateSigner",
    values: [BigNumberish, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "updateSignerUpdateLimit",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "updateValidatorContractAddress",
    values: [BigNumberish, string]
  ): string;
  encodeFunctionData(
    functionFragment: "updateValidatorDelegation",
    values: [boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "updateValidatorState",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "updateValidatorThreshold",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "userFeeExit", values: [string]): string;
  encodeFunctionData(
    functionFragment: "validatorAuction",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "validatorReward",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "validatorShareFactory",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "validatorStake",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "validatorState",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "validatorStateChanges",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "validatorThreshold",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "validators",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "withdrawDelegatorsReward",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "withdrawRewards",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "withdrawalDelay",
    values?: undefined
  ): string;

  decodeFunctionResult(
    functionFragment: "CHECKPOINT_REWARD",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "NFTContract",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "NFTCounter", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "WITHDRAWAL_DELAY",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "accountStateRoot",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "auctionPeriod",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "changeRootChain",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "checkPointBlockInterval",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "checkSignatures",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "checkpointRewardDelta",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "claimFee", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "confirmAuctionBid",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "currentEpoch",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "currentValidatorSetSize",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "currentValidatorSetTotalStake",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "decreaseValidatorDelegatedAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "delegatedAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "delegationDeposit",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "delegationEnabled",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "delegatorsReward",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "dethroneAndStake",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "drain", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "drainValidatorShares",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "dynasty", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "epoch", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "eventsHub", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "extensionCode",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "forceUnstake",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getRegistry",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getValidatorContract",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getValidatorId",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "governance", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "insertSigners",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "isOwner", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "isValidator",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "latestSignerUpdateEpoch",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "lock", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "locked", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "logger", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "maxRewardedCheckpoints",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "migrateDelegation",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "migrateValidatorsData",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "minDeposit", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "minHeimdallFee",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "ownerOf", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "prevBlockInterval",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "proposerBonus",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "registry", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "reinitialize",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "renounceOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "replacementCoolDown",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "restake", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "rewardDecreasePerCheckpoint",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "rewardPerStake",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "rootChain", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setCurrentEpoch",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setDelegationEnabled",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setStakingToken",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "signerToValidator",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "signerUpdateLimit",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "signers", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "slash", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "stakeFor", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "startAuction",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "stopAuctions",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "token", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "topUpForFee",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "totalHeimdallFee",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "totalRewards",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "totalRewardsLiquidated",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "totalStaked",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "totalStakedFor",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "transferFunds",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "transferOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "unjail", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "unlock", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "unstake", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "unstakeClaim",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateCheckPointBlockInterval",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateCheckpointReward",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateCheckpointRewardParams",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateCommissionRate",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateDynastyValue",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateMinAmounts",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateProposerBonus",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateSigner",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateSignerUpdateLimit",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateValidatorContractAddress",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateValidatorDelegation",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateValidatorState",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateValidatorThreshold",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "userFeeExit",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "validatorAuction",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "validatorReward",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "validatorShareFactory",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "validatorStake",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "validatorState",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "validatorStateChanges",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "validatorThreshold",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "validators", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "withdrawDelegatorsReward",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "withdrawRewards",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "withdrawalDelay",
    data: BytesLike
  ): Result;

  events: {
    "OwnershipTransferred(address,address)": EventFragment;
    "RootChainChanged(address,address)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RootChainChanged"): EventFragment;
}

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

export type RootChainChangedEvent = TypedEvent<
  [string, string] & { previousRootChain: string; newRootChain: string }
>;

export class StakeManagerAbi 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: StakeManagerAbiInterface;

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

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

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

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

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

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

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

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

    checkSignatures(
      blockInterval: BigNumberish,
      voteHash: BytesLike,
      stateRoot: BytesLike,
      proposer: string,
      sigs: [BigNumberish, BigNumberish, BigNumberish][],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    claimFee(
      accumFeeAmount: BigNumberish,
      index: BigNumberish,
      proof: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    confirmAuctionBid(
      validatorId: BigNumberish,
      heimdallFee: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

    delegatedAmount(
      validatorId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

    delegationEnabled(overrides?: CallOverrides): Promise<[boolean]>;

    delegatorsReward(
      validatorId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    dethroneAndStake(
      auctionUser: string,
      heimdallFee: BigNumberish,
      validatorId: BigNumberish,
      auctionAmount: BigNumberish,
      acceptDelegation: boolean,
      signerPubkey: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

    getValidatorContract(
      validatorId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[string]>;

    getValidatorId(
      user: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

    initialize(
      _registry: string,
      _rootchain: string,
      _token: string,
      _NFTContract: string,
      _stakingLogger: string,
      _validatorShareFactory: string,
      _governance: string,
      _owner: string,
      _extensionCode: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    insertSigners(
      _signers: string[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    isOwner(overrides?: CallOverrides): Promise<[boolean]>;

    isValidator(
      validatorId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    latestSignerUpdateEpoch(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

    locked(overrides?: CallOverrides): Promise<[boolean]>;

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

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

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

    migrateValidatorsData(
      validatorIdFrom: BigNumberish,
      validatorIdTo: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

    ownerOf(
      tokenId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[string]>;

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

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

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

    reinitialize(
      _NFTContract: string,
      _stakingLogger: string,
      _validatorShareFactory: string,
      _extensionCode: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

    setDelegationEnabled(
      enabled: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

    slash(
      _slashingInfoList: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    stakeFor(
      user: string,
      amount: BigNumberish,
      heimdallFee: BigNumberish,
      acceptDelegation: boolean,
      signerPubkey: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    startAuction(
      validatorId: BigNumberish,
      amount: BigNumberish,
      _acceptDelegation: boolean,
      _signerPubkey: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

    topUpForFee(
      user: string,
      heimdallFee: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

    totalStakedFor(
      user: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

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

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

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

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

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

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

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

    updateCheckpointRewardParams(
      _rewardDecreasePerCheckpoint: BigNumberish,
      _maxRewardedCheckpoints: BigNumberish,
      _checkpointRewardDelta: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    updateCommissionRate(
      validatorId: BigNumberish,
      newCommissionRate: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    updateMinAmounts(
      _minDeposit: BigNumberish,
      _minHeimdallFee: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    updateSigner(
      validatorId: BigNumberish,
      signerPubkey: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    updateValidatorContractAddress(
      validatorId: BigNumberish,
      newContractAddress: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    updateValidatorDelegation(
      delegation: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

    validatorAuction(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, string, boolean, string] & {
        amount: BigNumber;
        startEpoch: BigNumber;
        user: string;
        acceptDelegation: boolean;
        signerPubkey: string;
      }
    >;

    validatorReward(
      validatorId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

    validatorStake(
      validatorId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    validatorState(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & { amount: BigNumber; stakerCount: BigNumber }
    >;

    validatorStateChanges(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & { amount: BigNumber; stakerCount: BigNumber }
    >;

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

    validators(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        string,
        string,
        number,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber
      ] & {
        amount: BigNumber;
        reward: BigNumber;
        activationEpoch: BigNumber;
        deactivationEpoch: BigNumber;
        jailTime: BigNumber;
        signer: string;
        contractAddress: string;
        status: number;
        commissionRate: BigNumber;
        lastCommissionUpdate: BigNumber;
        delegatorsReward: BigNumber;
        delegatedAmount: BigNumber;
        initialRewardPerStake: BigNumber;
      }
    >;

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

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

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

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

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

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

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

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

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

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

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

  checkSignatures(
    blockInterval: BigNumberish,
    voteHash: BytesLike,
    stateRoot: BytesLike,
    proposer: string,
    sigs: [BigNumberish, BigNumberish, BigNumberish][],
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  claimFee(
    accumFeeAmount: BigNumberish,
    index: BigNumberish,
    proof: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  confirmAuctionBid(
    validatorId: BigNumberish,
    heimdallFee: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

  delegatedAmount(
    validatorId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

  delegationEnabled(overrides?: CallOverrides): Promise<boolean>;

  delegatorsReward(
    validatorId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  dethroneAndStake(
    auctionUser: string,
    heimdallFee: BigNumberish,
    validatorId: BigNumberish,
    auctionAmount: BigNumberish,
    acceptDelegation: boolean,
    signerPubkey: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

  getValidatorContract(
    validatorId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<string>;

  getValidatorId(user: string, overrides?: CallOverrides): Promise<BigNumber>;

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

  initialize(
    _registry: string,
    _rootchain: string,
    _token: string,
    _NFTContract: string,
    _stakingLogger: string,
    _validatorShareFactory: string,
    _governance: string,
    _owner: string,
    _extensionCode: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  insertSigners(
    _signers: string[],
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  isOwner(overrides?: CallOverrides): Promise<boolean>;

  isValidator(
    validatorId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<boolean>;

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

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

  locked(overrides?: CallOverrides): Promise<boolean>;

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

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

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

  migrateValidatorsData(
    validatorIdFrom: BigNumberish,
    validatorIdTo: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

  ownerOf(tokenId: BigNumberish, overrides?: CallOverrides): Promise<string>;

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

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

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

  reinitialize(
    _NFTContract: string,
    _stakingLogger: string,
    _validatorShareFactory: string,
    _extensionCode: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

  setDelegationEnabled(
    enabled: boolean,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

  slash(
    _slashingInfoList: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  stakeFor(
    user: string,
    amount: BigNumberish,
    heimdallFee: BigNumberish,
    acceptDelegation: boolean,
    signerPubkey: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  startAuction(
    validatorId: BigNumberish,
    amount: BigNumberish,
    _acceptDelegation: boolean,
    _signerPubkey: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

  topUpForFee(
    user: string,
    heimdallFee: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

  totalStakedFor(user: string, overrides?: CallOverrides): Promise<BigNumber>;

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

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

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

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

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

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

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

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

  updateCheckpointRewardParams(
    _rewardDecreasePerCheckpoint: BigNumberish,
    _maxRewardedCheckpoints: BigNumberish,
    _checkpointRewardDelta: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  updateCommissionRate(
    validatorId: BigNumberish,
    newCommissionRate: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  updateMinAmounts(
    _minDeposit: BigNumberish,
    _minHeimdallFee: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  updateSigner(
    validatorId: BigNumberish,
    signerPubkey: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  updateValidatorContractAddress(
    validatorId: BigNumberish,
    newContractAddress: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  updateValidatorDelegation(
    delegation: boolean,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

  validatorAuction(
    arg0: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber, string, boolean, string] & {
      amount: BigNumber;
      startEpoch: BigNumber;
      user: string;
      acceptDelegation: boolean;
      signerPubkey: string;
    }
  >;

  validatorReward(
    validatorId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

  validatorStake(
    validatorId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  validatorState(
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber] & { amount: BigNumber; stakerCount: BigNumber }
  >;

  validatorStateChanges(
    arg0: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber] & { amount: BigNumber; stakerCount: BigNumber }
  >;

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

  validators(
    arg0: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    [
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      string,
      string,
      number,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber
    ] & {
      amount: BigNumber;
      reward: BigNumber;
      activationEpoch: BigNumber;
      deactivationEpoch: BigNumber;
      jailTime: BigNumber;
      signer: string;
      contractAddress: string;
      status: number;
      commissionRate: BigNumber;
      lastCommissionUpdate: BigNumber;
      delegatorsReward: BigNumber;
      delegatedAmount: BigNumber;
      initialRewardPerStake: BigNumber;
    }
  >;

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

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

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

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

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

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

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

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

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

    changeRootChain(
      newRootChain: string,
      overrides?: CallOverrides
    ): Promise<void>;

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

    checkSignatures(
      blockInterval: BigNumberish,
      voteHash: BytesLike,
      stateRoot: BytesLike,
      proposer: string,
      sigs: [BigNumberish, BigNumberish, BigNumberish][],
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    claimFee(
      accumFeeAmount: BigNumberish,
      index: BigNumberish,
      proof: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

    confirmAuctionBid(
      validatorId: BigNumberish,
      heimdallFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

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

    delegatedAmount(
      validatorId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    delegationDeposit(
      validatorId: BigNumberish,
      amount: BigNumberish,
      delegator: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

    delegationEnabled(overrides?: CallOverrides): Promise<boolean>;

    delegatorsReward(
      validatorId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    dethroneAndStake(
      auctionUser: string,
      heimdallFee: BigNumberish,
      validatorId: BigNumberish,
      auctionAmount: BigNumberish,
      acceptDelegation: boolean,
      signerPubkey: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

    drain(
      destination: string,
      amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    drainValidatorShares(
      validatorId: BigNumberish,
      tokenAddr: string,
      destination: string,
      amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

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

    forceUnstake(
      validatorId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

    getValidatorContract(
      validatorId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string>;

    getValidatorId(user: string, overrides?: CallOverrides): Promise<BigNumber>;

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

    initialize(
      _registry: string,
      _rootchain: string,
      _token: string,
      _NFTContract: string,
      _stakingLogger: string,
      _validatorShareFactory: string,
      _governance: string,
      _owner: string,
      _extensionCode: string,
      overrides?: CallOverrides
    ): Promise<void>;

    insertSigners(_signers: string[], overrides?: CallOverrides): Promise<void>;

    isOwner(overrides?: CallOverrides): Promise<boolean>;

    isValidator(
      validatorId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

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

    locked(overrides?: CallOverrides): Promise<boolean>;

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

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

    migrateDelegation(
      fromValidatorId: BigNumberish,
      toValidatorId: BigNumberish,
      amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    migrateValidatorsData(
      validatorIdFrom: BigNumberish,
      validatorIdTo: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

    ownerOf(tokenId: BigNumberish, overrides?: CallOverrides): Promise<string>;

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

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

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

    reinitialize(
      _NFTContract: string,
      _stakingLogger: string,
      _validatorShareFactory: string,
      _extensionCode: string,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    restake(
      validatorId: BigNumberish,
      amount: BigNumberish,
      stakeRewards: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

    setCurrentEpoch(
      _currentEpoch: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setDelegationEnabled(
      enabled: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

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

    slash(
      _slashingInfoList: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    stakeFor(
      user: string,
      amount: BigNumberish,
      heimdallFee: BigNumberish,
      acceptDelegation: boolean,
      signerPubkey: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

    startAuction(
      validatorId: BigNumberish,
      amount: BigNumberish,
      _acceptDelegation: boolean,
      _signerPubkey: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

    stopAuctions(
      forNCheckpoints: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

    topUpForFee(
      user: string,
      heimdallFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

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

    totalStakedFor(user: string, overrides?: CallOverrides): Promise<BigNumber>;

    transferFunds(
      validatorId: BigNumberish,
      amount: BigNumberish,
      delegator: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

    unjail(validatorId: BigNumberish, overrides?: CallOverrides): Promise<void>;

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

    unstake(
      validatorId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    unstakeClaim(
      validatorId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    updateCheckPointBlockInterval(
      _blocks: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    updateCheckpointReward(
      newReward: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    updateCheckpointRewardParams(
      _rewardDecreasePerCheckpoint: BigNumberish,
      _maxRewardedCheckpoints: BigNumberish,
      _checkpointRewardDelta: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    updateCommissionRate(
      validatorId: BigNumberish,
      newCommissionRate: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    updateDynastyValue(
      newDynasty: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    updateMinAmounts(
      _minDeposit: BigNumberish,
      _minHeimdallFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    updateProposerBonus(
      newProposerBonus: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    updateSigner(
      validatorId: BigNumberish,
      signerPubkey: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

    updateSignerUpdateLimit(
      _limit: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    updateValidatorContractAddress(
      validatorId: BigNumberish,
      newContractAddress: string,
      overrides?: CallOverrides
    ): Promise<void>;

    updateValidatorDelegation(
      delegation: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

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

    updateValidatorThreshold(
      newThreshold: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

    validatorAuction(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, string, boolean, string] & {
        amount: BigNumber;
        startEpoch: BigNumber;
        user: string;
        acceptDelegation: boolean;
        signerPubkey: string;
      }
    >;

    validatorReward(
      validatorId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    validatorStake(
      validatorId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    validatorState(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & { amount: BigNumber; stakerCount: BigNumber }
    >;

    validatorStateChanges(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & { amount: BigNumber; stakerCount: BigNumber }
    >;

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

    validators(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        string,
        string,
        number,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber
      ] & {
        amount: BigNumber;
        reward: BigNumber;
        activationEpoch: BigNumber;
        deactivationEpoch: BigNumber;
        jailTime: BigNumber;
        signer: string;
        contractAddress: string;
        status: number;
        commissionRate: BigNumber;
        lastCommissionUpdate: BigNumber;
        delegatorsReward: BigNumber;
        delegatedAmount: BigNumber;
        initialRewardPerStake: BigNumber;
      }
    >;

    withdrawDelegatorsReward(
      validatorId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    withdrawRewards(
      validatorId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    withdrawalDelay(overrides?: CallOverrides): Promise<BigNumber>;
  };

  filters: {
    "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 }
    >;

    "RootChainChanged(address,address)"(
      previousRootChain?: string | null,
      newRootChain?: string | null
    ): TypedEventFilter<
      [string, string],
      { previousRootChain: string; newRootChain: string }
    >;

    RootChainChanged(
      previousRootChain?: string | null,
      newRootChain?: string | null
    ): TypedEventFilter<
      [string, string],
      { previousRootChain: string; newRootChain: string }
    >;
  };

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

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

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

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

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

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

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

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

    checkSignatures(
      blockInterval: BigNumberish,
      voteHash: BytesLike,
      stateRoot: BytesLike,
      proposer: string,
      sigs: [BigNumberish, BigNumberish, BigNumberish][],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    claimFee(
      accumFeeAmount: BigNumberish,
      index: BigNumberish,
      proof: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    confirmAuctionBid(
      validatorId: BigNumberish,
      heimdallFee: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

    delegatedAmount(
      validatorId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    delegatorsReward(
      validatorId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    dethroneAndStake(
      auctionUser: string,
      heimdallFee: BigNumberish,
      validatorId: BigNumberish,
      auctionAmount: BigNumberish,
      acceptDelegation: boolean,
      signerPubkey: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

    getValidatorContract(
      validatorId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getValidatorId(user: string, overrides?: CallOverrides): Promise<BigNumber>;

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

    initialize(
      _registry: string,
      _rootchain: string,
      _token: string,
      _NFTContract: string,
      _stakingLogger: string,
      _validatorShareFactory: string,
      _governance: string,
      _owner: string,
      _extensionCode: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    insertSigners(
      _signers: string[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    isValidator(
      validatorId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

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

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

    migrateValidatorsData(
      validatorIdFrom: BigNumberish,
      validatorIdTo: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

    ownerOf(
      tokenId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

    reinitialize(
      _NFTContract: string,
      _stakingLogger: string,
      _validatorShareFactory: string,
      _extensionCode: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

    setDelegationEnabled(
      enabled: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

    slash(
      _slashingInfoList: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    stakeFor(
      user: string,
      amount: BigNumberish,
      heimdallFee: BigNumberish,
      acceptDelegation: boolean,
      signerPubkey: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    startAuction(
      validatorId: BigNumberish,
      amount: BigNumberish,
      _acceptDelegation: boolean,
      _signerPubkey: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

    topUpForFee(
      user: string,
      heimdallFee: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

    totalStakedFor(user: string, overrides?: CallOverrides): Promise<BigNumber>;

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

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

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

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

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

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

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

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

    updateCheckpointRewardParams(
      _rewardDecreasePerCheckpoint: BigNumberish,
      _maxRewardedCheckpoints: BigNumberish,
      _checkpointRewardDelta: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    updateCommissionRate(
      validatorId: BigNumberish,
      newCommissionRate: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    updateMinAmounts(
      _minDeposit: BigNumberish,
      _minHeimdallFee: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    updateSigner(
      validatorId: BigNumberish,
      signerPubkey: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    updateValidatorContractAddress(
      validatorId: BigNumberish,
      newContractAddress: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    updateValidatorDelegation(
      delegation: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

    validatorReward(
      validatorId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    validatorStake(
      validatorId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

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

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

    withdrawalDelay(overrides?: CallOverrides): Promise<BigNumber>;
  };

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

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

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

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

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

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

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

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

    checkSignatures(
      blockInterval: BigNumberish,
      voteHash: BytesLike,
      stateRoot: BytesLike,
      proposer: string,
      sigs: [BigNumberish, BigNumberish, BigNumberish][],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    claimFee(
      accumFeeAmount: BigNumberish,
      index: BigNumberish,
      proof: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    confirmAuctionBid(
      validatorId: BigNumberish,
      heimdallFee: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

    delegatedAmount(
      validatorId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    delegatorsReward(
      validatorId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    dethroneAndStake(
      auctionUser: string,
      heimdallFee: BigNumberish,
      validatorId: BigNumberish,
      auctionAmount: BigNumberish,
      acceptDelegation: boolean,
      signerPubkey: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

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

    getValidatorContract(
      validatorId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getValidatorId(
      user: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    initialize(
      _registry: string,
      _rootchain: string,
      _token: string,
      _NFTContract: string,
      _stakingLogger: string,
      _validatorShareFactory: string,
      _governance: string,
      _owner: string,
      _extensionCode: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    insertSigners(
      _signers: string[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    isValidator(
      validatorId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

    migrateValidatorsData(
      validatorIdFrom: BigNumberish,
      validatorIdTo: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

    ownerOf(
      tokenId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

    reinitialize(
      _NFTContract: string,
      _stakingLogger: string,
      _validatorShareFactory: string,
      _extensionCode: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

    setDelegationEnabled(
      enabled: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

    slash(
      _slashingInfoList: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    stakeFor(
      user: string,
      amount: BigNumberish,
      heimdallFee: BigNumberish,
      acceptDelegation: boolean,
      signerPubkey: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    startAuction(
      validatorId: BigNumberish,
      amount: BigNumberish,
      _acceptDelegation: boolean,
      _signerPubkey: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

    topUpForFee(
      user: string,
      heimdallFee: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

    totalStakedFor(
      user: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

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

    updateCheckpointRewardParams(
      _rewardDecreasePerCheckpoint: BigNumberish,
      _maxRewardedCheckpoints: BigNumberish,
      _checkpointRewardDelta: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    updateCommissionRate(
      validatorId: BigNumberish,
      newCommissionRate: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    updateMinAmounts(
      _minDeposit: BigNumberish,
      _minHeimdallFee: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    updateSigner(
      validatorId: BigNumberish,
      signerPubkey: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    updateValidatorContractAddress(
      validatorId: BigNumberish,
      newContractAddress: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    updateValidatorDelegation(
      delegation: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

    validatorReward(
      validatorId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    validatorStake(
      validatorId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

    withdrawalDelay(overrides?: CallOverrides): Promise<PopulatedTransaction>;
  };
}