/* 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 KnboneAbiInterface extends ethers.utils.Interface {
  functions: {
    "BRIDGE_ROLE()": FunctionFragment;
    "DAO_ROLE()": FunctionFragment;
    "DEFAULT_ADMIN_ROLE()": FunctionFragment;
    "PAUSE_ROLE()": FunctionFragment;
    "UNPAUSE_ROLE()": FunctionFragment;
    "allowance(address,address)": FunctionFragment;
    "approve(address,uint256)": FunctionFragment;
    "balanceOf(address)": FunctionFragment;
    "bridge()": FunctionFragment;
    "calculatePendingBufferedTokens()": FunctionFragment;
    "claimTokens(uint256[])": FunctionFragment;
    "claimTokensFromValidatorToContract(uint256)": FunctionFragment;
    "convertBONEToKnBONE(uint256)": FunctionFragment;
    "convertKnBONEToBONE(uint256)": FunctionFragment;
    "dao()": FunctionFragment;
    "decimals()": FunctionFragment;
    "decreaseAllowance(address,uint256)": FunctionFragment;
    "delegate()": FunctionFragment;
    "delegationLowerBound()": FunctionFragment;
    "depositManager()": FunctionFragment;
    "distributeRewards()": FunctionFragment;
    "entityFees()": FunctionFragment;
    "getBONEFromTokenId(uint256)": FunctionFragment;
    "getLiquidRewards(address)": FunctionFragment;
    "getRoleAdmin(bytes32)": FunctionFragment;
    "getToken2WithdrawRequests(uint256)": FunctionFragment;
    "getTotalPooledBONE()": FunctionFragment;
    "getTotalStake(address)": FunctionFragment;
    "getTotalStakeAcrossAllValidators()": FunctionFragment;
    "getTotalWithdrawRequest()": FunctionFragment;
    "grantRole(bytes32,address)": FunctionFragment;
    "hasRole(bytes32,address)": FunctionFragment;
    "increaseAllowance(address,uint256)": FunctionFragment;
    "initialize(address,address,address,address,address,address,address,address,address)": FunctionFragment;
    "instantPool()": FunctionFragment;
    "instantPoolUsageFee()": FunctionFragment;
    "knBONEWithdrawRequest(uint256)": FunctionFragment;
    "l2Staking()": FunctionFragment;
    "name()": FunctionFragment;
    "nodeOperatorRegistry()": FunctionFragment;
    "pause()": FunctionFragment;
    "paused()": FunctionFragment;
    "protocolFee()": FunctionFragment;
    "rebalanceDelegatedTokens()": FunctionFragment;
    "renounceRole(bytes32,address)": FunctionFragment;
    "requestWithdrawSplit(uint256,uint256,address)": FunctionFragment;
    "reservedFunds()": FunctionFragment;
    "revokeRole(bytes32,address)": FunctionFragment;
    "rewardDistributionLowerBound()": FunctionFragment;
    "setBridge(address)": FunctionFragment;
    "setDaoAddress(address)": FunctionFragment;
    "setDelegationLowerBound(uint256)": FunctionFragment;
    "setDepositManager(address)": FunctionFragment;
    "setFees(uint8,uint8,uint8,uint8)": FunctionFragment;
    "setInstantPool(address)": FunctionFragment;
    "setInstantPoolUsageFee(uint256)": FunctionFragment;
    "setL2Staking(address)": FunctionFragment;
    "setNodeOperatorRegistryAddress(address)": FunctionFragment;
    "setProtocolFee(uint8)": FunctionFragment;
    "setRewardDistributionLowerBound(uint256)": FunctionFragment;
    "setUnstBONE(address)": FunctionFragment;
    "stakeManager()": FunctionFragment;
    "submit(uint256,address,bool)": FunctionFragment;
    "supportsInterface(bytes4)": FunctionFragment;
    "symbol()": FunctionFragment;
    "token()": FunctionFragment;
    "token2WithdrawRequests(uint256,uint256)": FunctionFragment;
    "totalBuffered()": FunctionFragment;
    "totalSupply()": FunctionFragment;
    "transfer(address,uint256)": FunctionFragment;
    "transferFrom(address,address,uint256)": FunctionFragment;
    "unpause()": FunctionFragment;
    "unstBONE()": FunctionFragment;
    "withdrawTotalDelegated(address)": FunctionFragment;
  };

  encodeFunctionData(
    functionFragment: "BRIDGE_ROLE",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "DAO_ROLE", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "DEFAULT_ADMIN_ROLE",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "PAUSE_ROLE",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "UNPAUSE_ROLE",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "allowance",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "approve",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "balanceOf", values: [string]): string;
  encodeFunctionData(functionFragment: "bridge", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "calculatePendingBufferedTokens",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "claimTokens",
    values: [BigNumberish[]]
  ): string;
  encodeFunctionData(
    functionFragment: "claimTokensFromValidatorToContract",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "convertBONEToKnBONE",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "convertKnBONEToBONE",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "dao", values?: undefined): string;
  encodeFunctionData(functionFragment: "decimals", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "decreaseAllowance",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "delegate", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "delegationLowerBound",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "depositManager",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "distributeRewards",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "entityFees",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getBONEFromTokenId",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getLiquidRewards",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "getRoleAdmin",
    values: [BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "getToken2WithdrawRequests",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getTotalPooledBONE",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getTotalStake",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "getTotalStakeAcrossAllValidators",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getTotalWithdrawRequest",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "grantRole",
    values: [BytesLike, string]
  ): string;
  encodeFunctionData(
    functionFragment: "hasRole",
    values: [BytesLike, string]
  ): string;
  encodeFunctionData(
    functionFragment: "increaseAllowance",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "initialize",
    values: [
      string,
      string,
      string,
      string,
      string,
      string,
      string,
      string,
      string
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "instantPool",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "instantPoolUsageFee",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "knBONEWithdrawRequest",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "l2Staking", values?: undefined): string;
  encodeFunctionData(functionFragment: "name", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "nodeOperatorRegistry",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "pause", values?: undefined): string;
  encodeFunctionData(functionFragment: "paused", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "protocolFee",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "rebalanceDelegatedTokens",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "renounceRole",
    values: [BytesLike, string]
  ): string;
  encodeFunctionData(
    functionFragment: "requestWithdrawSplit",
    values: [BigNumberish, BigNumberish, string]
  ): string;
  encodeFunctionData(
    functionFragment: "reservedFunds",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "revokeRole",
    values: [BytesLike, string]
  ): string;
  encodeFunctionData(
    functionFragment: "rewardDistributionLowerBound",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "setBridge", values: [string]): string;
  encodeFunctionData(
    functionFragment: "setDaoAddress",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setDelegationLowerBound",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setDepositManager",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setFees",
    values: [BigNumberish, BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setInstantPool",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setInstantPoolUsageFee",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setL2Staking",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setNodeOperatorRegistryAddress",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setProtocolFee",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setRewardDistributionLowerBound",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "setUnstBONE", values: [string]): string;
  encodeFunctionData(
    functionFragment: "stakeManager",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "submit",
    values: [BigNumberish, string, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "supportsInterface",
    values: [BytesLike]
  ): string;
  encodeFunctionData(functionFragment: "symbol", values?: undefined): string;
  encodeFunctionData(functionFragment: "token", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "token2WithdrawRequests",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "totalBuffered",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "totalSupply",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "transfer",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "transferFrom",
    values: [string, string, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "unpause", values?: undefined): string;
  encodeFunctionData(functionFragment: "unstBONE", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "withdrawTotalDelegated",
    values: [string]
  ): string;

  decodeFunctionResult(
    functionFragment: "BRIDGE_ROLE",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "DAO_ROLE", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "DEFAULT_ADMIN_ROLE",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "PAUSE_ROLE", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "UNPAUSE_ROLE",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "bridge", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "calculatePendingBufferedTokens",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "claimTokens",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "claimTokensFromValidatorToContract",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "convertBONEToKnBONE",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "convertKnBONEToBONE",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "dao", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "decreaseAllowance",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "delegate", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "delegationLowerBound",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "depositManager",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "distributeRewards",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "entityFees", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getBONEFromTokenId",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getLiquidRewards",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getRoleAdmin",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getToken2WithdrawRequests",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getTotalPooledBONE",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getTotalStake",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getTotalStakeAcrossAllValidators",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getTotalWithdrawRequest",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "grantRole", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "hasRole", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "increaseAllowance",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "instantPool",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "instantPoolUsageFee",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "knBONEWithdrawRequest",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "l2Staking", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "nodeOperatorRegistry",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "pause", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "paused", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "protocolFee",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "rebalanceDelegatedTokens",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "renounceRole",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "requestWithdrawSplit",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "reservedFunds",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "revokeRole", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "rewardDistributionLowerBound",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "setBridge", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setDaoAddress",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setDelegationLowerBound",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setDepositManager",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "setFees", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setInstantPool",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setInstantPoolUsageFee",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setL2Staking",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setNodeOperatorRegistryAddress",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setProtocolFee",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setRewardDistributionLowerBound",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setUnstBONE",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "stakeManager",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "submit", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "supportsInterface",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "token", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "token2WithdrawRequests",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "totalBuffered",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "totalSupply",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "transferFrom",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "unpause", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "unstBONE", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "withdrawTotalDelegated",
    data: BytesLike
  ): Result;

  events: {
    "Approval(address,address,uint256)": EventFragment;
    "ClaimTokensEvent(address,uint256,uint256)": EventFragment;
    "ClaimTotalDelegatedEvent(address,uint256)": EventFragment;
    "DelegateEvent(uint256,uint256)": EventFragment;
    "DistributeRewardsEvent(uint256,uint256,uint256)": EventFragment;
    "InstantPoolWithdraw(address,uint256,uint256)": EventFragment;
    "Paused(address)": EventFragment;
    "RequestWithdrawEvent(address,uint256)": EventFragment;
    "RequestWithdrawSplit(address,uint256)": EventFragment;
    "RoleAdminChanged(bytes32,bytes32,bytes32)": EventFragment;
    "RoleGranted(bytes32,address,address)": EventFragment;
    "RoleRevoked(bytes32,address,address)": EventFragment;
    "SetBridge(address)": EventFragment;
    "SetDaoAddress(address,address)": EventFragment;
    "SetDelegationLowerBound(uint256)": EventFragment;
    "SetDepositManager(address)": EventFragment;
    "SetFees(uint256,uint256,uint256,uint256)": EventFragment;
    "SetInstantPool(address)": EventFragment;
    "SetInstantPoolUsageFee(uint256,uint256)": EventFragment;
    "SetL2Staking(address)": EventFragment;
    "SetNodeOperatorRegistryAddress(address)": EventFragment;
    "SetProtocolFee(uint8,uint8)": EventFragment;
    "SetRewardDistributionLowerBound(uint256,uint256)": EventFragment;
    "SetUnstBONE(address,address)": EventFragment;
    "SubmitEvent(address,uint256,address,bool)": EventFragment;
    "Transfer(address,address,uint256)": EventFragment;
    "Unpaused(address)": EventFragment;
    "WithdrawTotalDelegatedEvent(address,uint256)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ClaimTokensEvent"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ClaimTotalDelegatedEvent"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "DelegateEvent"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "DistributeRewardsEvent"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "InstantPoolWithdraw"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Paused"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RequestWithdrawEvent"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RequestWithdrawSplit"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RoleAdminChanged"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RoleGranted"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RoleRevoked"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SetBridge"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SetDaoAddress"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SetDelegationLowerBound"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SetDepositManager"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SetFees"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SetInstantPool"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SetInstantPoolUsageFee"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SetL2Staking"): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "SetNodeOperatorRegistryAddress"
  ): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SetProtocolFee"): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "SetRewardDistributionLowerBound"
  ): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SetUnstBONE"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SubmitEvent"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Unpaused"): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "WithdrawTotalDelegatedEvent"
  ): EventFragment;
}

export type ApprovalEvent = TypedEvent<
  [string, string, BigNumber] & {
    owner: string;
    spender: string;
    value: BigNumber;
  }
>;

export type ClaimTokensEventEvent = TypedEvent<
  [string, BigNumber, BigNumber] & {
    _from: string;
    _id: BigNumber;
    _amountClaimed: BigNumber;
  }
>;

export type ClaimTotalDelegatedEventEvent = TypedEvent<
  [string, BigNumber] & { validatorShare: string; amountClaimed: BigNumber }
>;

export type DelegateEventEvent = TypedEvent<
  [BigNumber, BigNumber] & {
    _amountDelegated: BigNumber;
    _remainder: BigNumber;
  }
>;

export type DistributeRewardsEventEvent = TypedEvent<
  [BigNumber, BigNumber, BigNumber] & {
    _amount: BigNumber;
    totalPooledBefore: BigNumber;
    totalPooledAfter: BigNumber;
  }
>;

export type InstantPoolWithdrawEvent = TypedEvent<
  [string, BigNumber, BigNumber] & {
    _from: string;
    _amountWithFeeInBONE: BigNumber;
    _feeAmountInBONE: BigNumber;
  }
>;

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

export type RequestWithdrawEventEvent = TypedEvent<
  [string, BigNumber] & { _from: string; _amountInBONE: BigNumber }
>;

export type RequestWithdrawSplitEvent = TypedEvent<
  [string, BigNumber] & { _from: string; _totalAmountInKnBONE: BigNumber }
>;

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 SetBridgeEvent = TypedEvent<[string] & { bridge: string }>;

export type SetDaoAddressEvent = TypedEvent<
  [string, string] & { oldDaoAddress: string; newDaoAddress: string }
>;

export type SetDelegationLowerBoundEvent = TypedEvent<
  [BigNumber] & { _delegationLowerBound: BigNumber }
>;

export type SetDepositManagerEvent = TypedEvent<
  [string] & { depositManager: string }
>;

export type SetFeesEvent = TypedEvent<
  [BigNumber, BigNumber, BigNumber, BigNumber] & {
    daoFee: BigNumber;
    operatorsFee: BigNumber;
    instantPoolFee: BigNumber;
    stakingFee: BigNumber;
  }
>;

export type SetInstantPoolEvent = TypedEvent<
  [string] & { instantPool: string }
>;

export type SetInstantPoolUsageFeeEvent = TypedEvent<
  [BigNumber, BigNumber] & {
    oldInstantPoolUsageFee: BigNumber;
    newInstantPoolUsageFee: BigNumber;
  }
>;

export type SetL2StakingEvent = TypedEvent<[string] & { l2Staking: string }>;

export type SetNodeOperatorRegistryAddressEvent = TypedEvent<
  [string] & { _newNodeOperatorRegistryAddress: string }
>;

export type SetProtocolFeeEvent = TypedEvent<
  [number, number] & { oldProtocolFee: number; newProtocolFee: number }
>;

export type SetRewardDistributionLowerBoundEvent = TypedEvent<
  [BigNumber, BigNumber] & {
    oldRewardDistributionLowerBound: BigNumber;
    newRewardDistributionLowerBound: BigNumber;
  }
>;

export type SetUnstBONEEvent = TypedEvent<
  [string, string] & { oldUnstBONE: string; newUnstBONE: string }
>;

export type SubmitEventEvent = TypedEvent<
  [string, BigNumber, string, boolean] & {
    _from: string;
    _amount: BigNumber;
    _receiver: string;
    _transferToL2: boolean;
  }
>;

export type TransferEvent = TypedEvent<
  [string, string, BigNumber] & { from: string; to: string; value: BigNumber }
>;

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

export type WithdrawTotalDelegatedEventEvent = TypedEvent<
  [string, BigNumber] & { _from: string; _amount: BigNumber }
>;

export class KnboneAbi 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: KnboneAbiInterface;

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

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

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

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

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

    allowance(
      owner: string,
      spender: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

    balanceOf(account: string, overrides?: CallOverrides): Promise<[BigNumber]>;

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

    calculatePendingBufferedTokens(
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { pendingBufferedTokens: BigNumber }>;

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

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

    convertBONEToKnBONE(
      _amountInBONE: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber] & {
        amountInKnBONE: BigNumber;
        totalKnBONESupply: BigNumber;
        totalPooledBONE: BigNumber;
      }
    >;

    convertKnBONEToBONE(
      _amountInKnBONE: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber] & {
        amountInBONE: BigNumber;
        totalKnBONEAmount: BigNumber;
        totalPooledBONE: BigNumber;
      }
    >;

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

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

    decreaseAllowance(
      spender: string,
      subtractedValue: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

    entityFees(
      overrides?: CallOverrides
    ): Promise<
      [number, number, number, number] & {
        dao: number;
        operators: number;
        instantPool: number;
        staking: number;
      }
    >;

    getBONEFromTokenId(
      _tokenId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    getLiquidRewards(
      _validatorShare: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

    getToken2WithdrawRequests(
      _tokenId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [
        ([BigNumber, BigNumber, BigNumber, string] & {
          amount2WithdrawFromKnBONE: BigNumber;
          validatorNonce: BigNumber;
          requestEpoch: BigNumber;
          validatorAddress: string;
        })[]
      ]
    >;

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

    getTotalStake(
      _validatorShare: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber, BigNumber]>;

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

    getTotalWithdrawRequest(
      overrides?: CallOverrides
    ): Promise<
      [
        ([BigNumber, BigNumber, BigNumber, string] & {
          amount2WithdrawFromKnBONE: BigNumber;
          validatorNonce: BigNumber;
          requestEpoch: BigNumber;
          validatorAddress: string;
        })[]
      ]
    >;

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

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

    increaseAllowance(
      spender: string,
      addedValue: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    initialize(
      _nodeOperatorRegistry: string,
      _token: string,
      _dao: string,
      _stakeManager: string,
      _unstBONE: string,
      _instantPool: string,
      _depositManager: string,
      _bridge: string,
      _l2Staking: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

    knBONEWithdrawRequest(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber, string] & {
        amount2WithdrawFromKnBONE: BigNumber;
        validatorNonce: BigNumber;
        requestEpoch: BigNumber;
        validatorAddress: string;
      }
    >;

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

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

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

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

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

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

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

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

    requestWithdrawSplit(
      _instantPoolAmount: BigNumberish,
      _requestWithdrawAmount: BigNumberish,
      _user: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

    setFees(
      _daoFee: BigNumberish,
      _operatorsFee: BigNumberish,
      _instantPoolFee: BigNumberish,
      _stakingFee: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

    submit(
      _amount: BigNumberish,
      _receiver: string,
      _transferToL2: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

    token2WithdrawRequests(
      arg0: BigNumberish,
      arg1: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber, string] & {
        amount2WithdrawFromKnBONE: BigNumber;
        validatorNonce: BigNumber;
        requestEpoch: BigNumber;
        validatorAddress: string;
      }
    >;

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

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

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

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

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

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

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

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

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

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

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

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

  allowance(
    owner: string,
    spender: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

  balanceOf(account: string, overrides?: CallOverrides): Promise<BigNumber>;

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

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

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

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

  convertBONEToKnBONE(
    _amountInBONE: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber, BigNumber] & {
      amountInKnBONE: BigNumber;
      totalKnBONESupply: BigNumber;
      totalPooledBONE: BigNumber;
    }
  >;

  convertKnBONEToBONE(
    _amountInKnBONE: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber, BigNumber] & {
      amountInBONE: BigNumber;
      totalKnBONEAmount: BigNumber;
      totalPooledBONE: BigNumber;
    }
  >;

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

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

  decreaseAllowance(
    spender: string,
    subtractedValue: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

  entityFees(
    overrides?: CallOverrides
  ): Promise<
    [number, number, number, number] & {
      dao: number;
      operators: number;
      instantPool: number;
      staking: number;
    }
  >;

  getBONEFromTokenId(
    _tokenId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  getLiquidRewards(
    _validatorShare: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

  getToken2WithdrawRequests(
    _tokenId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    ([BigNumber, BigNumber, BigNumber, string] & {
      amount2WithdrawFromKnBONE: BigNumber;
      validatorNonce: BigNumber;
      requestEpoch: BigNumber;
      validatorAddress: string;
    })[]
  >;

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

  getTotalStake(
    _validatorShare: string,
    overrides?: CallOverrides
  ): Promise<[BigNumber, BigNumber]>;

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

  getTotalWithdrawRequest(
    overrides?: CallOverrides
  ): Promise<
    ([BigNumber, BigNumber, BigNumber, string] & {
      amount2WithdrawFromKnBONE: BigNumber;
      validatorNonce: BigNumber;
      requestEpoch: BigNumber;
      validatorAddress: string;
    })[]
  >;

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

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

  increaseAllowance(
    spender: string,
    addedValue: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  initialize(
    _nodeOperatorRegistry: string,
    _token: string,
    _dao: string,
    _stakeManager: string,
    _unstBONE: string,
    _instantPool: string,
    _depositManager: string,
    _bridge: string,
    _l2Staking: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

  knBONEWithdrawRequest(
    arg0: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber, BigNumber, string] & {
      amount2WithdrawFromKnBONE: BigNumber;
      validatorNonce: BigNumber;
      requestEpoch: BigNumber;
      validatorAddress: string;
    }
  >;

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

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

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

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

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

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

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

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

  requestWithdrawSplit(
    _instantPoolAmount: BigNumberish,
    _requestWithdrawAmount: BigNumberish,
    _user: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

  setFees(
    _daoFee: BigNumberish,
    _operatorsFee: BigNumberish,
    _instantPoolFee: BigNumberish,
    _stakingFee: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

  submit(
    _amount: BigNumberish,
    _receiver: string,
    _transferToL2: boolean,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

  token2WithdrawRequests(
    arg0: BigNumberish,
    arg1: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber, BigNumber, string] & {
      amount2WithdrawFromKnBONE: BigNumber;
      validatorNonce: BigNumber;
      requestEpoch: BigNumber;
      validatorAddress: string;
    }
  >;

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

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

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

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

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

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

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

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

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

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

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

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

    allowance(
      owner: string,
      spender: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    approve(
      spender: string,
      amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    balanceOf(account: string, overrides?: CallOverrides): Promise<BigNumber>;

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

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

    claimTokens(
      _tokenId: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<void>;

    claimTokensFromValidatorToContract(
      _index: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    convertBONEToKnBONE(
      _amountInBONE: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber] & {
        amountInKnBONE: BigNumber;
        totalKnBONESupply: BigNumber;
        totalPooledBONE: BigNumber;
      }
    >;

    convertKnBONEToBONE(
      _amountInKnBONE: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber] & {
        amountInBONE: BigNumber;
        totalKnBONEAmount: BigNumber;
        totalPooledBONE: BigNumber;
      }
    >;

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

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

    decreaseAllowance(
      spender: string,
      subtractedValue: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

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

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

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

    entityFees(
      overrides?: CallOverrides
    ): Promise<
      [number, number, number, number] & {
        dao: number;
        operators: number;
        instantPool: number;
        staking: number;
      }
    >;

    getBONEFromTokenId(
      _tokenId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getLiquidRewards(
      _validatorShare: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    getToken2WithdrawRequests(
      _tokenId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      ([BigNumber, BigNumber, BigNumber, string] & {
        amount2WithdrawFromKnBONE: BigNumber;
        validatorNonce: BigNumber;
        requestEpoch: BigNumber;
        validatorAddress: string;
      })[]
    >;

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

    getTotalStake(
      _validatorShare: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber, BigNumber]>;

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

    getTotalWithdrawRequest(
      overrides?: CallOverrides
    ): Promise<
      ([BigNumber, BigNumber, BigNumber, string] & {
        amount2WithdrawFromKnBONE: BigNumber;
        validatorNonce: BigNumber;
        requestEpoch: BigNumber;
        validatorAddress: string;
      })[]
    >;

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

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

    increaseAllowance(
      spender: string,
      addedValue: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    initialize(
      _nodeOperatorRegistry: string,
      _token: string,
      _dao: string,
      _stakeManager: string,
      _unstBONE: string,
      _instantPool: string,
      _depositManager: string,
      _bridge: string,
      _l2Staking: string,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    knBONEWithdrawRequest(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber, string] & {
        amount2WithdrawFromKnBONE: BigNumber;
        validatorNonce: BigNumber;
        requestEpoch: BigNumber;
        validatorAddress: string;
      }
    >;

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

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

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

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

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

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

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

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

    requestWithdrawSplit(
      _instantPoolAmount: BigNumberish,
      _requestWithdrawAmount: BigNumberish,
      _user: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

    setBridge(_bridge: string, overrides?: CallOverrides): Promise<void>;

    setDaoAddress(_newDAO: string, overrides?: CallOverrides): Promise<void>;

    setDelegationLowerBound(
      _delegationLowerBound: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setDepositManager(
      _depositManager: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setFees(
      _daoFee: BigNumberish,
      _operatorsFee: BigNumberish,
      _instantPoolFee: BigNumberish,
      _stakingFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setInstantPool(
      _instantPool: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setInstantPoolUsageFee(
      _instantPoolUsageFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setL2Staking(_l2Staking: string, overrides?: CallOverrides): Promise<void>;

    setNodeOperatorRegistryAddress(
      _address: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setProtocolFee(
      _newProtocolFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setRewardDistributionLowerBound(
      _newRewardDistributionLowerBound: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setUnstBONE(_newUnstBONE: string, overrides?: CallOverrides): Promise<void>;

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

    submit(
      _amount: BigNumberish,
      _receiver: string,
      _transferToL2: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

    token2WithdrawRequests(
      arg0: BigNumberish,
      arg1: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber, string] & {
        amount2WithdrawFromKnBONE: BigNumber;
        validatorNonce: BigNumber;
        requestEpoch: BigNumber;
        validatorAddress: string;
      }
    >;

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

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

    transfer(
      to: string,
      amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    transferFrom(
      from: string,
      to: string,
      amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

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

    withdrawTotalDelegated(
      _validatorShare: string,
      overrides?: CallOverrides
    ): Promise<void>;
  };

  filters: {
    "Approval(address,address,uint256)"(
      owner?: string | null,
      spender?: string | null,
      value?: null
    ): TypedEventFilter<
      [string, string, BigNumber],
      { owner: string; spender: string; value: BigNumber }
    >;

    Approval(
      owner?: string | null,
      spender?: string | null,
      value?: null
    ): TypedEventFilter<
      [string, string, BigNumber],
      { owner: string; spender: string; value: BigNumber }
    >;

    "ClaimTokensEvent(address,uint256,uint256)"(
      _from?: string | null,
      _id?: BigNumberish | null,
      _amountClaimed?: BigNumberish | null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber],
      { _from: string; _id: BigNumber; _amountClaimed: BigNumber }
    >;

    ClaimTokensEvent(
      _from?: string | null,
      _id?: BigNumberish | null,
      _amountClaimed?: BigNumberish | null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber],
      { _from: string; _id: BigNumber; _amountClaimed: BigNumber }
    >;

    "ClaimTotalDelegatedEvent(address,uint256)"(
      validatorShare?: string | null,
      amountClaimed?: BigNumberish | null
    ): TypedEventFilter<
      [string, BigNumber],
      { validatorShare: string; amountClaimed: BigNumber }
    >;

    ClaimTotalDelegatedEvent(
      validatorShare?: string | null,
      amountClaimed?: BigNumberish | null
    ): TypedEventFilter<
      [string, BigNumber],
      { validatorShare: string; amountClaimed: BigNumber }
    >;

    "DelegateEvent(uint256,uint256)"(
      _amountDelegated?: BigNumberish | null,
      _remainder?: BigNumberish | null
    ): TypedEventFilter<
      [BigNumber, BigNumber],
      { _amountDelegated: BigNumber; _remainder: BigNumber }
    >;

    DelegateEvent(
      _amountDelegated?: BigNumberish | null,
      _remainder?: BigNumberish | null
    ): TypedEventFilter<
      [BigNumber, BigNumber],
      { _amountDelegated: BigNumber; _remainder: BigNumber }
    >;

    "DistributeRewardsEvent(uint256,uint256,uint256)"(
      _amount?: BigNumberish | null,
      totalPooledBefore?: BigNumberish | null,
      totalPooledAfter?: BigNumberish | null
    ): TypedEventFilter<
      [BigNumber, BigNumber, BigNumber],
      {
        _amount: BigNumber;
        totalPooledBefore: BigNumber;
        totalPooledAfter: BigNumber;
      }
    >;

    DistributeRewardsEvent(
      _amount?: BigNumberish | null,
      totalPooledBefore?: BigNumberish | null,
      totalPooledAfter?: BigNumberish | null
    ): TypedEventFilter<
      [BigNumber, BigNumber, BigNumber],
      {
        _amount: BigNumber;
        totalPooledBefore: BigNumber;
        totalPooledAfter: BigNumber;
      }
    >;

    "InstantPoolWithdraw(address,uint256,uint256)"(
      _from?: string | null,
      _amountWithFeeInBONE?: null,
      _feeAmountInBONE?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber],
      {
        _from: string;
        _amountWithFeeInBONE: BigNumber;
        _feeAmountInBONE: BigNumber;
      }
    >;

    InstantPoolWithdraw(
      _from?: string | null,
      _amountWithFeeInBONE?: null,
      _feeAmountInBONE?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber],
      {
        _from: string;
        _amountWithFeeInBONE: BigNumber;
        _feeAmountInBONE: BigNumber;
      }
    >;

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

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

    "RequestWithdrawEvent(address,uint256)"(
      _from?: string | null,
      _amountInBONE?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { _from: string; _amountInBONE: BigNumber }
    >;

    RequestWithdrawEvent(
      _from?: string | null,
      _amountInBONE?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { _from: string; _amountInBONE: BigNumber }
    >;

    "RequestWithdrawSplit(address,uint256)"(
      _from?: string | null,
      _totalAmountInKnBONE?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { _from: string; _totalAmountInKnBONE: BigNumber }
    >;

    RequestWithdrawSplit(
      _from?: string | null,
      _totalAmountInKnBONE?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { _from: string; _totalAmountInKnBONE: BigNumber }
    >;

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

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

    SetBridge(bridge?: null): TypedEventFilter<[string], { bridge: string }>;

    "SetDaoAddress(address,address)"(
      oldDaoAddress?: null,
      newDaoAddress?: null
    ): TypedEventFilter<
      [string, string],
      { oldDaoAddress: string; newDaoAddress: string }
    >;

    SetDaoAddress(
      oldDaoAddress?: null,
      newDaoAddress?: null
    ): TypedEventFilter<
      [string, string],
      { oldDaoAddress: string; newDaoAddress: string }
    >;

    "SetDelegationLowerBound(uint256)"(
      _delegationLowerBound?: BigNumberish | null
    ): TypedEventFilter<[BigNumber], { _delegationLowerBound: BigNumber }>;

    SetDelegationLowerBound(
      _delegationLowerBound?: BigNumberish | null
    ): TypedEventFilter<[BigNumber], { _delegationLowerBound: BigNumber }>;

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

    SetDepositManager(
      depositManager?: null
    ): TypedEventFilter<[string], { depositManager: string }>;

    "SetFees(uint256,uint256,uint256,uint256)"(
      daoFee?: null,
      operatorsFee?: null,
      instantPoolFee?: null,
      stakingFee?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber, BigNumber, BigNumber],
      {
        daoFee: BigNumber;
        operatorsFee: BigNumber;
        instantPoolFee: BigNumber;
        stakingFee: BigNumber;
      }
    >;

    SetFees(
      daoFee?: null,
      operatorsFee?: null,
      instantPoolFee?: null,
      stakingFee?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber, BigNumber, BigNumber],
      {
        daoFee: BigNumber;
        operatorsFee: BigNumber;
        instantPoolFee: BigNumber;
        stakingFee: BigNumber;
      }
    >;

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

    SetInstantPool(
      instantPool?: null
    ): TypedEventFilter<[string], { instantPool: string }>;

    "SetInstantPoolUsageFee(uint256,uint256)"(
      oldInstantPoolUsageFee?: null,
      newInstantPoolUsageFee?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber],
      { oldInstantPoolUsageFee: BigNumber; newInstantPoolUsageFee: BigNumber }
    >;

    SetInstantPoolUsageFee(
      oldInstantPoolUsageFee?: null,
      newInstantPoolUsageFee?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber],
      { oldInstantPoolUsageFee: BigNumber; newInstantPoolUsageFee: BigNumber }
    >;

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

    SetL2Staking(
      l2Staking?: null
    ): TypedEventFilter<[string], { l2Staking: string }>;

    "SetNodeOperatorRegistryAddress(address)"(
      _newNodeOperatorRegistryAddress?: string | null
    ): TypedEventFilter<[string], { _newNodeOperatorRegistryAddress: string }>;

    SetNodeOperatorRegistryAddress(
      _newNodeOperatorRegistryAddress?: string | null
    ): TypedEventFilter<[string], { _newNodeOperatorRegistryAddress: string }>;

    "SetProtocolFee(uint8,uint8)"(
      oldProtocolFee?: null,
      newProtocolFee?: null
    ): TypedEventFilter<
      [number, number],
      { oldProtocolFee: number; newProtocolFee: number }
    >;

    SetProtocolFee(
      oldProtocolFee?: null,
      newProtocolFee?: null
    ): TypedEventFilter<
      [number, number],
      { oldProtocolFee: number; newProtocolFee: number }
    >;

    "SetRewardDistributionLowerBound(uint256,uint256)"(
      oldRewardDistributionLowerBound?: null,
      newRewardDistributionLowerBound?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber],
      {
        oldRewardDistributionLowerBound: BigNumber;
        newRewardDistributionLowerBound: BigNumber;
      }
    >;

    SetRewardDistributionLowerBound(
      oldRewardDistributionLowerBound?: null,
      newRewardDistributionLowerBound?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber],
      {
        oldRewardDistributionLowerBound: BigNumber;
        newRewardDistributionLowerBound: BigNumber;
      }
    >;

    "SetUnstBONE(address,address)"(
      oldUnstBONE?: null,
      newUnstBONE?: null
    ): TypedEventFilter<
      [string, string],
      { oldUnstBONE: string; newUnstBONE: string }
    >;

    SetUnstBONE(
      oldUnstBONE?: null,
      newUnstBONE?: null
    ): TypedEventFilter<
      [string, string],
      { oldUnstBONE: string; newUnstBONE: string }
    >;

    "SubmitEvent(address,uint256,address,bool)"(
      _from?: string | null,
      _amount?: null,
      _receiver?: string | null,
      _transferToL2?: null
    ): TypedEventFilter<
      [string, BigNumber, string, boolean],
      {
        _from: string;
        _amount: BigNumber;
        _receiver: string;
        _transferToL2: boolean;
      }
    >;

    SubmitEvent(
      _from?: string | null,
      _amount?: null,
      _receiver?: string | null,
      _transferToL2?: null
    ): TypedEventFilter<
      [string, BigNumber, string, boolean],
      {
        _from: string;
        _amount: BigNumber;
        _receiver: string;
        _transferToL2: boolean;
      }
    >;

    "Transfer(address,address,uint256)"(
      from?: string | null,
      to?: string | null,
      value?: null
    ): TypedEventFilter<
      [string, string, BigNumber],
      { from: string; to: string; value: BigNumber }
    >;

    Transfer(
      from?: string | null,
      to?: string | null,
      value?: null
    ): TypedEventFilter<
      [string, string, BigNumber],
      { from: string; to: string; value: BigNumber }
    >;

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

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

    "WithdrawTotalDelegatedEvent(address,uint256)"(
      _from?: string | null,
      _amount?: BigNumberish | null
    ): TypedEventFilter<
      [string, BigNumber],
      { _from: string; _amount: BigNumber }
    >;

    WithdrawTotalDelegatedEvent(
      _from?: string | null,
      _amount?: BigNumberish | null
    ): TypedEventFilter<
      [string, BigNumber],
      { _from: string; _amount: BigNumber }
    >;
  };

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

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

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

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

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

    allowance(
      owner: string,
      spender: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    balanceOf(account: string, overrides?: CallOverrides): Promise<BigNumber>;

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

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

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

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

    convertBONEToKnBONE(
      _amountInBONE: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    convertKnBONEToBONE(
      _amountInKnBONE: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    decreaseAllowance(
      spender: string,
      subtractedValue: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

    getBONEFromTokenId(
      _tokenId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getLiquidRewards(
      _validatorShare: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    getToken2WithdrawRequests(
      _tokenId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    getTotalStake(
      _validatorShare: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    increaseAllowance(
      spender: string,
      addedValue: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    initialize(
      _nodeOperatorRegistry: string,
      _token: string,
      _dao: string,
      _stakeManager: string,
      _unstBONE: string,
      _instantPool: string,
      _depositManager: string,
      _bridge: string,
      _l2Staking: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

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

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

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

    requestWithdrawSplit(
      _instantPoolAmount: BigNumberish,
      _requestWithdrawAmount: BigNumberish,
      _user: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

    setFees(
      _daoFee: BigNumberish,
      _operatorsFee: BigNumberish,
      _instantPoolFee: BigNumberish,
      _stakingFee: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

    submit(
      _amount: BigNumberish,
      _receiver: string,
      _transferToL2: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    allowance(
      owner: string,
      spender: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    balanceOf(
      account: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

    convertBONEToKnBONE(
      _amountInBONE: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    convertKnBONEToBONE(
      _amountInKnBONE: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    decreaseAllowance(
      spender: string,
      subtractedValue: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

    getBONEFromTokenId(
      _tokenId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getLiquidRewards(
      _validatorShare: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    getToken2WithdrawRequests(
      _tokenId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    getTotalStake(
      _validatorShare: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    increaseAllowance(
      spender: string,
      addedValue: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    initialize(
      _nodeOperatorRegistry: string,
      _token: string,
      _dao: string,
      _stakeManager: string,
      _unstBONE: string,
      _instantPool: string,
      _depositManager: string,
      _bridge: string,
      _l2Staking: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

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

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

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

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

    requestWithdrawSplit(
      _instantPoolAmount: BigNumberish,
      _requestWithdrawAmount: BigNumberish,
      _user: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

    setFees(
      _daoFee: BigNumberish,
      _operatorsFee: BigNumberish,
      _instantPoolFee: BigNumberish,
      _stakingFee: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

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

    submit(
      _amount: BigNumberish,
      _receiver: string,
      _transferToL2: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

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

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

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

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