/* 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 NodeOperatorRegistryAbiInterface extends ethers.utils.Interface {
  functions: {
    "ADD_NODE_OPERATOR_ROLE()": FunctionFragment;
    "DAO_ROLE()": FunctionFragment;
    "DEFAULT_ADMIN_ROLE()": FunctionFragment;
    "DISTANCE_THRESHOLD_PERCENTS()": FunctionFragment;
    "MAX_WITHDRAW_PERCENTAGE_PER_REBALANCE()": FunctionFragment;
    "MIN_REQUEST_WITHDRAW_RANGE_PERCENTS()": FunctionFragment;
    "PAUSE_ROLE()": FunctionFragment;
    "REMOVE_NODE_OPERATOR_ROLE()": FunctionFragment;
    "UNPAUSE_ROLE()": FunctionFragment;
    "addNodeOperator(uint256,address)": FunctionFragment;
    "exitNodeOperatorRegistry()": FunctionFragment;
    "getNodeOperator(address)": FunctionFragment;
    "getNodeOperatorStatus(uint256)": FunctionFragment;
    "getProtocolStats()": FunctionFragment;
    "getRoleAdmin(bytes32)": FunctionFragment;
    "getStats()": FunctionFragment;
    "getValidatorIds()": FunctionFragment;
    "getValidatorsDelegationAmount(uint256)": FunctionFragment;
    "getValidatorsRebalanceAmount(uint256)": FunctionFragment;
    "getValidatorsRequestWithdraw(uint256)": FunctionFragment;
    "grantRole(bytes32,address)": FunctionFragment;
    "hasRole(bytes32,address)": FunctionFragment;
    "initialize(address,address,address)": FunctionFragment;
    "knBONE()": FunctionFragment;
    "listDelegatedNodeOperators()": FunctionFragment;
    "listWithdrawNodeOperators()": FunctionFragment;
    "pause()": FunctionFragment;
    "paused()": FunctionFragment;
    "removeInvalidNodeOperator(uint256)": FunctionFragment;
    "removeNodeOperator(uint256)": FunctionFragment;
    "renounceRole(bytes32,address)": FunctionFragment;
    "revokeRole(bytes32,address)": FunctionFragment;
    "setDistanceThreshold(uint256)": FunctionFragment;
    "setKnBONEAddress(address)": FunctionFragment;
    "setMaxWithdrawPercentagePerRebalance(uint256)": FunctionFragment;
    "setMinRequestWithdrawRange(uint8)": FunctionFragment;
    "setRewardAddress(address)": FunctionFragment;
    "stakeManager()": FunctionFragment;
    "supportsInterface(bytes4)": FunctionFragment;
    "unpause()": FunctionFragment;
    "validatorIdToRewardAddress(uint256)": FunctionFragment;
    "validatorIds(uint256)": FunctionFragment;
    "validatorRewardAddressToId(address)": FunctionFragment;
  };

  encodeFunctionData(
    functionFragment: "ADD_NODE_OPERATOR_ROLE",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "DAO_ROLE", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "DEFAULT_ADMIN_ROLE",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "DISTANCE_THRESHOLD_PERCENTS",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "MAX_WITHDRAW_PERCENTAGE_PER_REBALANCE",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "MIN_REQUEST_WITHDRAW_RANGE_PERCENTS",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "PAUSE_ROLE",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "REMOVE_NODE_OPERATOR_ROLE",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "UNPAUSE_ROLE",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "addNodeOperator",
    values: [BigNumberish, string]
  ): string;
  encodeFunctionData(
    functionFragment: "exitNodeOperatorRegistry",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getNodeOperator",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "getNodeOperatorStatus",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getProtocolStats",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getRoleAdmin",
    values: [BytesLike]
  ): string;
  encodeFunctionData(functionFragment: "getStats", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "getValidatorIds",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getValidatorsDelegationAmount",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getValidatorsRebalanceAmount",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getValidatorsRequestWithdraw",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "grantRole",
    values: [BytesLike, string]
  ): string;
  encodeFunctionData(
    functionFragment: "hasRole",
    values: [BytesLike, string]
  ): string;
  encodeFunctionData(
    functionFragment: "initialize",
    values: [string, string, string]
  ): string;
  encodeFunctionData(functionFragment: "knBONE", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "listDelegatedNodeOperators",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "listWithdrawNodeOperators",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "pause", values?: undefined): string;
  encodeFunctionData(functionFragment: "paused", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "removeInvalidNodeOperator",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "removeNodeOperator",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "renounceRole",
    values: [BytesLike, string]
  ): string;
  encodeFunctionData(
    functionFragment: "revokeRole",
    values: [BytesLike, string]
  ): string;
  encodeFunctionData(
    functionFragment: "setDistanceThreshold",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setKnBONEAddress",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setMaxWithdrawPercentagePerRebalance",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setMinRequestWithdrawRange",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setRewardAddress",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "stakeManager",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "supportsInterface",
    values: [BytesLike]
  ): string;
  encodeFunctionData(functionFragment: "unpause", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "validatorIdToRewardAddress",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "validatorIds",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "validatorRewardAddressToId",
    values: [string]
  ): string;

  decodeFunctionResult(
    functionFragment: "ADD_NODE_OPERATOR_ROLE",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "DAO_ROLE", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "DEFAULT_ADMIN_ROLE",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "DISTANCE_THRESHOLD_PERCENTS",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "MAX_WITHDRAW_PERCENTAGE_PER_REBALANCE",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "MIN_REQUEST_WITHDRAW_RANGE_PERCENTS",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "PAUSE_ROLE", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "REMOVE_NODE_OPERATOR_ROLE",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "UNPAUSE_ROLE",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "addNodeOperator",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "exitNodeOperatorRegistry",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getNodeOperator",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getNodeOperatorStatus",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getProtocolStats",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getRoleAdmin",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "getStats", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getValidatorIds",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getValidatorsDelegationAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getValidatorsRebalanceAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getValidatorsRequestWithdraw",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "grantRole", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "hasRole", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "knBONE", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "listDelegatedNodeOperators",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "listWithdrawNodeOperators",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "pause", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "paused", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "removeInvalidNodeOperator",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "removeNodeOperator",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "renounceRole",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "revokeRole", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setDistanceThreshold",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setKnBONEAddress",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setMaxWithdrawPercentagePerRebalance",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setMinRequestWithdrawRange",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setRewardAddress",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "stakeManager",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "supportsInterface",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "unpause", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "validatorIdToRewardAddress",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "validatorIds",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "validatorRewardAddressToId",
    data: BytesLike
  ): Result;

  events: {
    "AddNodeOperator(uint256,address)": EventFragment;
    "ExitNodeOperator(uint256,address)": EventFragment;
    "Paused(address)": EventFragment;
    "RemoveInvalidNodeOperator(uint256,address)": EventFragment;
    "RemoveNodeOperator(uint256,address)": EventFragment;
    "RoleAdminChanged(bytes32,bytes32,bytes32)": EventFragment;
    "RoleGranted(bytes32,address,address)": EventFragment;
    "RoleRevoked(bytes32,address,address)": EventFragment;
    "SetDistanceThreshold(uint256,uint256)": EventFragment;
    "SetKnBONEAddress(address,address)": EventFragment;
    "SetMaxWithdrawPercentagePerRebalance(uint256,uint256)": EventFragment;
    "SetMinRequestWithdrawRange(uint8,uint8)": EventFragment;
    "SetRewardAddress(uint256,address,address)": EventFragment;
    "Unpaused(address)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "AddNodeOperator"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ExitNodeOperator"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Paused"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RemoveInvalidNodeOperator"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RemoveNodeOperator"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RoleAdminChanged"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RoleGranted"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RoleRevoked"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SetDistanceThreshold"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SetKnBONEAddress"): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "SetMaxWithdrawPercentagePerRebalance"
  ): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SetMinRequestWithdrawRange"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SetRewardAddress"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Unpaused"): EventFragment;
}

export type AddNodeOperatorEvent = TypedEvent<
  [BigNumber, string] & { validatorId: BigNumber; rewardAddress: string }
>;

export type ExitNodeOperatorEvent = TypedEvent<
  [BigNumber, string] & { validatorId: BigNumber; rewardAddress: string }
>;

export type PausedEvent = TypedEvent<[string] & { account: string }>;

export type RemoveInvalidNodeOperatorEvent = TypedEvent<
  [BigNumber, string] & { validatorId: BigNumber; rewardAddress: string }
>;

export type RemoveNodeOperatorEvent = TypedEvent<
  [BigNumber, string] & { validatorId: BigNumber; rewardAddress: string }
>;

export type RoleAdminChangedEvent = TypedEvent<
  [string, string, string] & {
    role: string;
    previousAdminRole: string;
    newAdminRole: string;
  }
>;

export type RoleGrantedEvent = TypedEvent<
  [string, string, string] & { role: string; account: string; sender: string }
>;

export type RoleRevokedEvent = TypedEvent<
  [string, string, string] & { role: string; account: string; sender: string }
>;

export type SetDistanceThresholdEvent = TypedEvent<
  [BigNumber, BigNumber] & {
    oldDistanceThreshold: BigNumber;
    newDistanceThreshold: BigNumber;
  }
>;

export type SetKnBONEAddressEvent = TypedEvent<
  [string, string] & { oldKnBONE: string; newKnBONE: string }
>;

export type SetMaxWithdrawPercentagePerRebalanceEvent = TypedEvent<
  [BigNumber, BigNumber] & {
    oldMaxWithdrawPercentagePerRebalance: BigNumber;
    newMaxWithdrawPercentagePerRebalance: BigNumber;
  }
>;

export type SetMinRequestWithdrawRangeEvent = TypedEvent<
  [number, number] & {
    oldMinRequestWithdrawRange: number;
    newMinRequestWithdrawRange: number;
  }
>;

export type SetRewardAddressEvent = TypedEvent<
  [BigNumber, string, string] & {
    validatorId: BigNumber;
    oldRewardAddress: string;
    newRewardAddress: string;
  }
>;

export type UnpausedEvent = TypedEvent<[string] & { account: string }>;

export class NodeOperatorRegistryAbi 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: NodeOperatorRegistryAbiInterface;

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

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

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

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

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

    MIN_REQUEST_WITHDRAW_RANGE_PERCENTS(
      overrides?: CallOverrides
    ): Promise<[number]>;

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

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

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

    addNodeOperator(
      _validatorId: BigNumberish,
      _rewardAddress: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    "getNodeOperator(address)"(
      _rewardAddress: string,
      overrides?: CallOverrides
    ): Promise<
      [
        [BigNumber, BigNumber, string, string, boolean, number] & {
          validatorId: BigNumber;
          commissionRate: BigNumber;
          validatorShare: string;
          rewardAddress: string;
          delegation: boolean;
          status: number;
        }
      ] & {
        nodeOperator: [
          BigNumber,
          BigNumber,
          string,
          string,
          boolean,
          number
        ] & {
          validatorId: BigNumber;
          commissionRate: BigNumber;
          validatorShare: string;
          rewardAddress: string;
          delegation: boolean;
          status: number;
        };
      }
    >;

    "getNodeOperator(uint256)"(
      _validatorId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [
        [BigNumber, BigNumber, string, string, boolean, number] & {
          validatorId: BigNumber;
          commissionRate: BigNumber;
          validatorShare: string;
          rewardAddress: string;
          delegation: boolean;
          status: number;
        }
      ] & {
        nodeOperator: [
          BigNumber,
          BigNumber,
          string,
          string,
          boolean,
          number
        ] & {
          validatorId: BigNumber;
          commissionRate: BigNumber;
          validatorShare: string;
          rewardAddress: string;
          delegation: boolean;
          status: number;
        };
      }
    >;

    getNodeOperatorStatus(
      _validatorId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[number] & { operatorStatus: number }>;

    getProtocolStats(
      overrides?: CallOverrides
    ): Promise<
      [boolean, BigNumber, BigNumber, BigNumber] & {
        isBalanced: boolean;
        distanceMinMaxStake: BigNumber;
        minAmount: BigNumber;
        maxAmount: BigNumber;
      }
    >;

    getRoleAdmin(role: BytesLike, overrides?: CallOverrides): Promise<[string]>;

    getStats(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
        inactiveNodeOperator: BigNumber;
        activeNodeOperator: BigNumber;
        jailedNodeOperator: BigNumber;
        ejectedNodeOperator: BigNumber;
        unstakedNodeOperator: BigNumber;
      }
    >;

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

    getValidatorsDelegationAmount(
      _amountToDelegate: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [
        ([string, string] & {
          validatorShare: string;
          rewardAddress: string;
        })[],
        BigNumber[],
        BigNumber
      ] & {
        validators: ([string, string] & {
          validatorShare: string;
          rewardAddress: string;
        })[];
        operatorRatiosToDelegate: BigNumber[];
        totalRatio: BigNumber;
      }
    >;

    getValidatorsRebalanceAmount(
      _amountToReDelegate: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [
        ([string, string] & {
          validatorShare: string;
          rewardAddress: string;
        })[],
        BigNumber[],
        BigNumber,
        BigNumber
      ] & {
        validators: ([string, string] & {
          validatorShare: string;
          rewardAddress: string;
        })[];
        operatorRatiosToRebalance: BigNumber[];
        totalRatio: BigNumber;
        totalToWithdraw: BigNumber;
      }
    >;

    getValidatorsRequestWithdraw(
      _withdrawAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [
        ([string, string] & {
          validatorShare: string;
          rewardAddress: string;
        })[],
        BigNumber,
        BigNumber[],
        BigNumber[],
        BigNumber[],
        BigNumber
      ] & {
        validators: ([string, string] & {
          validatorShare: string;
          rewardAddress: string;
        })[];
        totalDelegated: BigNumber;
        bigNodeOperatorIds: BigNumber[];
        smallNodeOperatorIds: BigNumber[];
        operatorAmountCanBeRequested: BigNumber[];
        totalValidatorToWithdrawFrom: BigNumber;
      }
    >;

    grantRole(
      role: BytesLike,
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    hasRole(
      role: BytesLike,
      account: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    initialize(
      _stakeManager: string,
      _knBONE: string,
      _dao: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    listDelegatedNodeOperators(
      overrides?: CallOverrides
    ): Promise<
      [([string, string] & { validatorShare: string; rewardAddress: string })[]]
    >;

    listWithdrawNodeOperators(
      overrides?: CallOverrides
    ): Promise<
      [([string, string] & { validatorShare: string; rewardAddress: string })[]]
    >;

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

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

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

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

    renounceRole(
      role: BytesLike,
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    revokeRole(
      role: BytesLike,
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

    supportsInterface(
      interfaceId: BytesLike,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

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

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

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

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

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

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

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

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

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

  MIN_REQUEST_WITHDRAW_RANGE_PERCENTS(
    overrides?: CallOverrides
  ): Promise<number>;

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

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

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

  addNodeOperator(
    _validatorId: BigNumberish,
    _rewardAddress: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  "getNodeOperator(address)"(
    _rewardAddress: string,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber, string, string, boolean, number] & {
      validatorId: BigNumber;
      commissionRate: BigNumber;
      validatorShare: string;
      rewardAddress: string;
      delegation: boolean;
      status: number;
    }
  >;

  "getNodeOperator(uint256)"(
    _validatorId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber, string, string, boolean, number] & {
      validatorId: BigNumber;
      commissionRate: BigNumber;
      validatorShare: string;
      rewardAddress: string;
      delegation: boolean;
      status: number;
    }
  >;

  getNodeOperatorStatus(
    _validatorId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<number>;

  getProtocolStats(
    overrides?: CallOverrides
  ): Promise<
    [boolean, BigNumber, BigNumber, BigNumber] & {
      isBalanced: boolean;
      distanceMinMaxStake: BigNumber;
      minAmount: BigNumber;
      maxAmount: BigNumber;
    }
  >;

  getRoleAdmin(role: BytesLike, overrides?: CallOverrides): Promise<string>;

  getStats(
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
      inactiveNodeOperator: BigNumber;
      activeNodeOperator: BigNumber;
      jailedNodeOperator: BigNumber;
      ejectedNodeOperator: BigNumber;
      unstakedNodeOperator: BigNumber;
    }
  >;

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

  getValidatorsDelegationAmount(
    _amountToDelegate: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    [
      ([string, string] & { validatorShare: string; rewardAddress: string })[],
      BigNumber[],
      BigNumber
    ] & {
      validators: ([string, string] & {
        validatorShare: string;
        rewardAddress: string;
      })[];
      operatorRatiosToDelegate: BigNumber[];
      totalRatio: BigNumber;
    }
  >;

  getValidatorsRebalanceAmount(
    _amountToReDelegate: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    [
      ([string, string] & { validatorShare: string; rewardAddress: string })[],
      BigNumber[],
      BigNumber,
      BigNumber
    ] & {
      validators: ([string, string] & {
        validatorShare: string;
        rewardAddress: string;
      })[];
      operatorRatiosToRebalance: BigNumber[];
      totalRatio: BigNumber;
      totalToWithdraw: BigNumber;
    }
  >;

  getValidatorsRequestWithdraw(
    _withdrawAmount: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    [
      ([string, string] & { validatorShare: string; rewardAddress: string })[],
      BigNumber,
      BigNumber[],
      BigNumber[],
      BigNumber[],
      BigNumber
    ] & {
      validators: ([string, string] & {
        validatorShare: string;
        rewardAddress: string;
      })[];
      totalDelegated: BigNumber;
      bigNodeOperatorIds: BigNumber[];
      smallNodeOperatorIds: BigNumber[];
      operatorAmountCanBeRequested: BigNumber[];
      totalValidatorToWithdrawFrom: BigNumber;
    }
  >;

  grantRole(
    role: BytesLike,
    account: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  hasRole(
    role: BytesLike,
    account: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

  initialize(
    _stakeManager: string,
    _knBONE: string,
    _dao: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  listDelegatedNodeOperators(
    overrides?: CallOverrides
  ): Promise<
    ([string, string] & { validatorShare: string; rewardAddress: string })[]
  >;

  listWithdrawNodeOperators(
    overrides?: CallOverrides
  ): Promise<
    ([string, string] & { validatorShare: string; rewardAddress: string })[]
  >;

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

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

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

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

  renounceRole(
    role: BytesLike,
    account: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  revokeRole(
    role: BytesLike,
    account: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

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

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

  supportsInterface(
    interfaceId: BytesLike,
    overrides?: CallOverrides
  ): Promise<boolean>;

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

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

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

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

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

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

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

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

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

    MIN_REQUEST_WITHDRAW_RANGE_PERCENTS(
      overrides?: CallOverrides
    ): Promise<number>;

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

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

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

    addNodeOperator(
      _validatorId: BigNumberish,
      _rewardAddress: string,
      overrides?: CallOverrides
    ): Promise<void>;

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

    "getNodeOperator(address)"(
      _rewardAddress: string,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, string, string, boolean, number] & {
        validatorId: BigNumber;
        commissionRate: BigNumber;
        validatorShare: string;
        rewardAddress: string;
        delegation: boolean;
        status: number;
      }
    >;

    "getNodeOperator(uint256)"(
      _validatorId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, string, string, boolean, number] & {
        validatorId: BigNumber;
        commissionRate: BigNumber;
        validatorShare: string;
        rewardAddress: string;
        delegation: boolean;
        status: number;
      }
    >;

    getNodeOperatorStatus(
      _validatorId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<number>;

    getProtocolStats(
      overrides?: CallOverrides
    ): Promise<
      [boolean, BigNumber, BigNumber, BigNumber] & {
        isBalanced: boolean;
        distanceMinMaxStake: BigNumber;
        minAmount: BigNumber;
        maxAmount: BigNumber;
      }
    >;

    getRoleAdmin(role: BytesLike, overrides?: CallOverrides): Promise<string>;

    getStats(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
        inactiveNodeOperator: BigNumber;
        activeNodeOperator: BigNumber;
        jailedNodeOperator: BigNumber;
        ejectedNodeOperator: BigNumber;
        unstakedNodeOperator: BigNumber;
      }
    >;

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

    getValidatorsDelegationAmount(
      _amountToDelegate: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [
        ([string, string] & {
          validatorShare: string;
          rewardAddress: string;
        })[],
        BigNumber[],
        BigNumber
      ] & {
        validators: ([string, string] & {
          validatorShare: string;
          rewardAddress: string;
        })[];
        operatorRatiosToDelegate: BigNumber[];
        totalRatio: BigNumber;
      }
    >;

    getValidatorsRebalanceAmount(
      _amountToReDelegate: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [
        ([string, string] & {
          validatorShare: string;
          rewardAddress: string;
        })[],
        BigNumber[],
        BigNumber,
        BigNumber
      ] & {
        validators: ([string, string] & {
          validatorShare: string;
          rewardAddress: string;
        })[];
        operatorRatiosToRebalance: BigNumber[];
        totalRatio: BigNumber;
        totalToWithdraw: BigNumber;
      }
    >;

    getValidatorsRequestWithdraw(
      _withdrawAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [
        ([string, string] & {
          validatorShare: string;
          rewardAddress: string;
        })[],
        BigNumber,
        BigNumber[],
        BigNumber[],
        BigNumber[],
        BigNumber
      ] & {
        validators: ([string, string] & {
          validatorShare: string;
          rewardAddress: string;
        })[];
        totalDelegated: BigNumber;
        bigNodeOperatorIds: BigNumber[];
        smallNodeOperatorIds: BigNumber[];
        operatorAmountCanBeRequested: BigNumber[];
        totalValidatorToWithdrawFrom: BigNumber;
      }
    >;

    grantRole(
      role: BytesLike,
      account: string,
      overrides?: CallOverrides
    ): Promise<void>;

    hasRole(
      role: BytesLike,
      account: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

    initialize(
      _stakeManager: string,
      _knBONE: string,
      _dao: string,
      overrides?: CallOverrides
    ): Promise<void>;

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

    listDelegatedNodeOperators(
      overrides?: CallOverrides
    ): Promise<
      ([string, string] & { validatorShare: string; rewardAddress: string })[]
    >;

    listWithdrawNodeOperators(
      overrides?: CallOverrides
    ): Promise<
      ([string, string] & { validatorShare: string; rewardAddress: string })[]
    >;

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

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

    removeInvalidNodeOperator(
      _validatorId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    removeNodeOperator(
      _validatorId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    renounceRole(
      role: BytesLike,
      account: string,
      overrides?: CallOverrides
    ): Promise<void>;

    revokeRole(
      role: BytesLike,
      account: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setDistanceThreshold(
      _newDistanceThreshold: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setKnBONEAddress(
      _newKnBONE: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setMaxWithdrawPercentagePerRebalance(
      _newMaxWithdrawPercentagePerRebalance: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setMinRequestWithdrawRange(
      _newMinRequestWithdrawRangePercents: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setRewardAddress(
      _newRewardAddress: string,
      overrides?: CallOverrides
    ): Promise<void>;

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

    supportsInterface(
      interfaceId: BytesLike,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

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

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

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

  filters: {
    "AddNodeOperator(uint256,address)"(
      validatorId?: null,
      rewardAddress?: null
    ): TypedEventFilter<
      [BigNumber, string],
      { validatorId: BigNumber; rewardAddress: string }
    >;

    AddNodeOperator(
      validatorId?: null,
      rewardAddress?: null
    ): TypedEventFilter<
      [BigNumber, string],
      { validatorId: BigNumber; rewardAddress: string }
    >;

    "ExitNodeOperator(uint256,address)"(
      validatorId?: null,
      rewardAddress?: null
    ): TypedEventFilter<
      [BigNumber, string],
      { validatorId: BigNumber; rewardAddress: string }
    >;

    ExitNodeOperator(
      validatorId?: null,
      rewardAddress?: null
    ): TypedEventFilter<
      [BigNumber, string],
      { validatorId: BigNumber; rewardAddress: string }
    >;

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

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

    "RemoveInvalidNodeOperator(uint256,address)"(
      validatorId?: null,
      rewardAddress?: null
    ): TypedEventFilter<
      [BigNumber, string],
      { validatorId: BigNumber; rewardAddress: string }
    >;

    RemoveInvalidNodeOperator(
      validatorId?: null,
      rewardAddress?: null
    ): TypedEventFilter<
      [BigNumber, string],
      { validatorId: BigNumber; rewardAddress: string }
    >;

    "RemoveNodeOperator(uint256,address)"(
      validatorId?: null,
      rewardAddress?: null
    ): TypedEventFilter<
      [BigNumber, string],
      { validatorId: BigNumber; rewardAddress: string }
    >;

    RemoveNodeOperator(
      validatorId?: null,
      rewardAddress?: null
    ): TypedEventFilter<
      [BigNumber, string],
      { validatorId: BigNumber; rewardAddress: string }
    >;

    "RoleAdminChanged(bytes32,bytes32,bytes32)"(
      role?: BytesLike | null,
      previousAdminRole?: BytesLike | null,
      newAdminRole?: BytesLike | null
    ): TypedEventFilter<
      [string, string, string],
      { role: string; previousAdminRole: string; newAdminRole: string }
    >;

    RoleAdminChanged(
      role?: BytesLike | null,
      previousAdminRole?: BytesLike | null,
      newAdminRole?: BytesLike | null
    ): TypedEventFilter<
      [string, string, string],
      { role: string; previousAdminRole: string; newAdminRole: string }
    >;

    "RoleGranted(bytes32,address,address)"(
      role?: BytesLike | null,
      account?: string | null,
      sender?: string | null
    ): TypedEventFilter<
      [string, string, string],
      { role: string; account: string; sender: string }
    >;

    RoleGranted(
      role?: BytesLike | null,
      account?: string | null,
      sender?: string | null
    ): TypedEventFilter<
      [string, string, string],
      { role: string; account: string; sender: string }
    >;

    "RoleRevoked(bytes32,address,address)"(
      role?: BytesLike | null,
      account?: string | null,
      sender?: string | null
    ): TypedEventFilter<
      [string, string, string],
      { role: string; account: string; sender: string }
    >;

    RoleRevoked(
      role?: BytesLike | null,
      account?: string | null,
      sender?: string | null
    ): TypedEventFilter<
      [string, string, string],
      { role: string; account: string; sender: string }
    >;

    "SetDistanceThreshold(uint256,uint256)"(
      oldDistanceThreshold?: null,
      newDistanceThreshold?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber],
      { oldDistanceThreshold: BigNumber; newDistanceThreshold: BigNumber }
    >;

    SetDistanceThreshold(
      oldDistanceThreshold?: null,
      newDistanceThreshold?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber],
      { oldDistanceThreshold: BigNumber; newDistanceThreshold: BigNumber }
    >;

    "SetKnBONEAddress(address,address)"(
      oldKnBONE?: null,
      newKnBONE?: null
    ): TypedEventFilter<
      [string, string],
      { oldKnBONE: string; newKnBONE: string }
    >;

    SetKnBONEAddress(
      oldKnBONE?: null,
      newKnBONE?: null
    ): TypedEventFilter<
      [string, string],
      { oldKnBONE: string; newKnBONE: string }
    >;

    "SetMaxWithdrawPercentagePerRebalance(uint256,uint256)"(
      oldMaxWithdrawPercentagePerRebalance?: null,
      newMaxWithdrawPercentagePerRebalance?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber],
      {
        oldMaxWithdrawPercentagePerRebalance: BigNumber;
        newMaxWithdrawPercentagePerRebalance: BigNumber;
      }
    >;

    SetMaxWithdrawPercentagePerRebalance(
      oldMaxWithdrawPercentagePerRebalance?: null,
      newMaxWithdrawPercentagePerRebalance?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber],
      {
        oldMaxWithdrawPercentagePerRebalance: BigNumber;
        newMaxWithdrawPercentagePerRebalance: BigNumber;
      }
    >;

    "SetMinRequestWithdrawRange(uint8,uint8)"(
      oldMinRequestWithdrawRange?: null,
      newMinRequestWithdrawRange?: null
    ): TypedEventFilter<
      [number, number],
      { oldMinRequestWithdrawRange: number; newMinRequestWithdrawRange: number }
    >;

    SetMinRequestWithdrawRange(
      oldMinRequestWithdrawRange?: null,
      newMinRequestWithdrawRange?: null
    ): TypedEventFilter<
      [number, number],
      { oldMinRequestWithdrawRange: number; newMinRequestWithdrawRange: number }
    >;

    "SetRewardAddress(uint256,address,address)"(
      validatorId?: null,
      oldRewardAddress?: null,
      newRewardAddress?: null
    ): TypedEventFilter<
      [BigNumber, string, string],
      {
        validatorId: BigNumber;
        oldRewardAddress: string;
        newRewardAddress: string;
      }
    >;

    SetRewardAddress(
      validatorId?: null,
      oldRewardAddress?: null,
      newRewardAddress?: null
    ): TypedEventFilter<
      [BigNumber, string, string],
      {
        validatorId: BigNumber;
        oldRewardAddress: string;
        newRewardAddress: string;
      }
    >;

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

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

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

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

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

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

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

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

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

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

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

    addNodeOperator(
      _validatorId: BigNumberish,
      _rewardAddress: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    "getNodeOperator(address)"(
      _rewardAddress: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getNodeOperator(uint256)"(
      _validatorId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getNodeOperatorStatus(
      _validatorId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    getRoleAdmin(
      role: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    getValidatorsDelegationAmount(
      _amountToDelegate: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getValidatorsRebalanceAmount(
      _amountToReDelegate: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getValidatorsRequestWithdraw(
      _withdrawAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    grantRole(
      role: BytesLike,
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    hasRole(
      role: BytesLike,
      account: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    initialize(
      _stakeManager: string,
      _knBONE: string,
      _dao: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

    renounceRole(
      role: BytesLike,
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    revokeRole(
      role: BytesLike,
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

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

    supportsInterface(
      interfaceId: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

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

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

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

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

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

    addNodeOperator(
      _validatorId: BigNumberish,
      _rewardAddress: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    "getNodeOperator(address)"(
      _rewardAddress: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "getNodeOperator(uint256)"(
      _validatorId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getNodeOperatorStatus(
      _validatorId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    getRoleAdmin(
      role: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    getValidatorsDelegationAmount(
      _amountToDelegate: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getValidatorsRebalanceAmount(
      _amountToReDelegate: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getValidatorsRequestWithdraw(
      _withdrawAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    grantRole(
      role: BytesLike,
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    hasRole(
      role: BytesLike,
      account: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    initialize(
      _stakeManager: string,
      _knBONE: string,
      _dao: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

    renounceRole(
      role: BytesLike,
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    revokeRole(
      role: BytesLike,
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

    supportsInterface(
      interfaceId: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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