/* Autogenerated file. Do not edit manually. */
/* tslint:disable */
/* eslint-disable */

import {
  ethers,
  EventFilter,
  Signer,
  BigNumber,
  BigNumberish,
  PopulatedTransaction,
  BaseContract,
  ContractTransaction,
  Overrides,
  PayableOverrides,
  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 StethAbiInterface extends ethers.utils.Interface {
  functions: {
    "resume()": FunctionFragment;
    "name()": FunctionFragment;
    "stop()": FunctionFragment;
    "hasInitialized()": FunctionFragment;
    "approve(address,uint256)": FunctionFragment;
    "STAKING_CONTROL_ROLE()": FunctionFragment;
    "totalSupply()": FunctionFragment;
    "getSharesByPooledEth(uint256)": FunctionFragment;
    "isStakingPaused()": FunctionFragment;
    "transferFrom(address,address,uint256)": FunctionFragment;
    "getEVMScriptExecutor(bytes)": FunctionFragment;
    "setStakingLimit(uint256,uint256)": FunctionFragment;
    "RESUME_ROLE()": FunctionFragment;
    "finalizeUpgrade_v2(address,address)": FunctionFragment;
    "decimals()": FunctionFragment;
    "getRecoveryVault()": FunctionFragment;
    "DOMAIN_SEPARATOR()": FunctionFragment;
    "getTotalPooledEther()": FunctionFragment;
    "unsafeChangeDepositedValidators(uint256)": FunctionFragment;
    "PAUSE_ROLE()": FunctionFragment;
    "increaseAllowance(address,uint256)": FunctionFragment;
    "getTreasury()": FunctionFragment;
    "isStopped()": FunctionFragment;
    "getBufferedEther()": FunctionFragment;
    "initialize(address,address)": FunctionFragment;
    "receiveELRewards()": FunctionFragment;
    "getWithdrawalCredentials()": FunctionFragment;
    "getCurrentStakeLimit()": FunctionFragment;
    "getStakeLimitFullInfo()": FunctionFragment;
    "transferSharesFrom(address,address,uint256)": FunctionFragment;
    "balanceOf(address)": FunctionFragment;
    "resumeStaking()": FunctionFragment;
    "getFeeDistribution()": FunctionFragment;
    "receiveWithdrawals()": FunctionFragment;
    "getPooledEthByShares(uint256)": FunctionFragment;
    "allowRecoverability(address)": FunctionFragment;
    "nonces(address)": FunctionFragment;
    "appId()": FunctionFragment;
    "getOracle()": FunctionFragment;
    "eip712Domain()": FunctionFragment;
    "getContractVersion()": FunctionFragment;
    "getInitializationBlock()": FunctionFragment;
    "transferShares(address,uint256)": FunctionFragment;
    "symbol()": FunctionFragment;
    "getEIP712StETH()": FunctionFragment;
    "transferToVault(address)": FunctionFragment;
    "canPerform(address,bytes32,uint256[])": FunctionFragment;
    "submit(address)": FunctionFragment;
    "decreaseAllowance(address,uint256)": FunctionFragment;
    "getEVMScriptRegistry()": FunctionFragment;
    "transfer(address,uint256)": FunctionFragment;
    "deposit(uint256,uint256,bytes)": FunctionFragment;
    "UNSAFE_CHANGE_DEPOSITED_VALIDATORS_ROLE()": FunctionFragment;
    "getBeaconStat()": FunctionFragment;
    "removeStakingLimit()": FunctionFragment;
    "handleOracleReport(uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256[],uint256)": FunctionFragment;
    "getFee()": FunctionFragment;
    "kernel()": FunctionFragment;
    "getTotalShares()": FunctionFragment;
    "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)": FunctionFragment;
    "allowance(address,address)": FunctionFragment;
    "isPetrified()": FunctionFragment;
    "getLidoLocator()": FunctionFragment;
    "canDeposit()": FunctionFragment;
    "STAKING_PAUSE_ROLE()": FunctionFragment;
    "getDepositableEther()": FunctionFragment;
    "sharesOf(address)": FunctionFragment;
    "pauseStaking()": FunctionFragment;
    "getTotalELRewardsCollected()": FunctionFragment;
  };

  encodeFunctionData(functionFragment: "resume", values?: undefined): string;
  encodeFunctionData(functionFragment: "name", values?: undefined): string;
  encodeFunctionData(functionFragment: "stop", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "hasInitialized",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "approve",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "STAKING_CONTROL_ROLE",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "totalSupply",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getSharesByPooledEth",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "isStakingPaused",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "transferFrom",
    values: [string, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getEVMScriptExecutor",
    values: [BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "setStakingLimit",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "RESUME_ROLE",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "finalizeUpgrade_v2",
    values: [string, string]
  ): string;
  encodeFunctionData(functionFragment: "decimals", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "getRecoveryVault",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "DOMAIN_SEPARATOR",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getTotalPooledEther",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "unsafeChangeDepositedValidators",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "PAUSE_ROLE",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "increaseAllowance",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getTreasury",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "isStopped", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "getBufferedEther",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "initialize",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "receiveELRewards",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getWithdrawalCredentials",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getCurrentStakeLimit",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getStakeLimitFullInfo",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "transferSharesFrom",
    values: [string, string, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "balanceOf", values: [string]): string;
  encodeFunctionData(
    functionFragment: "resumeStaking",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getFeeDistribution",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "receiveWithdrawals",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getPooledEthByShares",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "allowRecoverability",
    values: [string]
  ): string;
  encodeFunctionData(functionFragment: "nonces", values: [string]): string;
  encodeFunctionData(functionFragment: "appId", values?: undefined): string;
  encodeFunctionData(functionFragment: "getOracle", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "eip712Domain",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getContractVersion",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getInitializationBlock",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "transferShares",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "symbol", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "getEIP712StETH",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "transferToVault",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "canPerform",
    values: [string, BytesLike, BigNumberish[]]
  ): string;
  encodeFunctionData(functionFragment: "submit", values: [string]): string;
  encodeFunctionData(
    functionFragment: "decreaseAllowance",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getEVMScriptRegistry",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "transfer",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "deposit",
    values: [BigNumberish, BigNumberish, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "UNSAFE_CHANGE_DEPOSITED_VALIDATORS_ROLE",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getBeaconStat",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "removeStakingLimit",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "handleOracleReport",
    values: [
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish[],
      BigNumberish
    ]
  ): string;
  encodeFunctionData(functionFragment: "getFee", values?: undefined): string;
  encodeFunctionData(functionFragment: "kernel", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "getTotalShares",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "permit",
    values: [
      string,
      string,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BytesLike,
      BytesLike
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "allowance",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "isPetrified",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getLidoLocator",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "canDeposit",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "STAKING_PAUSE_ROLE",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getDepositableEther",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "sharesOf", values: [string]): string;
  encodeFunctionData(
    functionFragment: "pauseStaking",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getTotalELRewardsCollected",
    values?: undefined
  ): string;

  decodeFunctionResult(functionFragment: "resume", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "stop", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "hasInitialized",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "STAKING_CONTROL_ROLE",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "totalSupply",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getSharesByPooledEth",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isStakingPaused",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "transferFrom",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getEVMScriptExecutor",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setStakingLimit",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "RESUME_ROLE",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "finalizeUpgrade_v2",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getRecoveryVault",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "DOMAIN_SEPARATOR",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getTotalPooledEther",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "unsafeChangeDepositedValidators",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "PAUSE_ROLE", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "increaseAllowance",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getTreasury",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "isStopped", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getBufferedEther",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "receiveELRewards",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getWithdrawalCredentials",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getCurrentStakeLimit",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getStakeLimitFullInfo",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "transferSharesFrom",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "resumeStaking",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getFeeDistribution",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "receiveWithdrawals",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getPooledEthByShares",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "allowRecoverability",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "nonces", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "appId", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "getOracle", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "eip712Domain",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getContractVersion",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getInitializationBlock",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "transferShares",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getEIP712StETH",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "transferToVault",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "canPerform", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "submit", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "decreaseAllowance",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getEVMScriptRegistry",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "deposit", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "UNSAFE_CHANGE_DEPOSITED_VALIDATORS_ROLE",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getBeaconStat",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "removeStakingLimit",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "handleOracleReport",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "getFee", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "kernel", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getTotalShares",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "permit", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "isPetrified",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getLidoLocator",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "canDeposit", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "STAKING_PAUSE_ROLE",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getDepositableEther",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "sharesOf", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "pauseStaking",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getTotalELRewardsCollected",
    data: BytesLike
  ): Result;

  events: {
    "StakingPaused()": EventFragment;
    "StakingResumed()": EventFragment;
    "StakingLimitSet(uint256,uint256)": EventFragment;
    "StakingLimitRemoved()": EventFragment;
    "CLValidatorsUpdated(uint256,uint256,uint256)": EventFragment;
    "DepositedValidatorsChanged(uint256)": EventFragment;
    "ETHDistributed(uint256,uint256,uint256,uint256,uint256,uint256)": EventFragment;
    "TokenRebased(uint256,uint256,uint256,uint256,uint256,uint256,uint256)": EventFragment;
    "LidoLocatorSet(address)": EventFragment;
    "ELRewardsReceived(uint256)": EventFragment;
    "WithdrawalsReceived(uint256)": EventFragment;
    "Submitted(address,uint256,address)": EventFragment;
    "Unbuffered(uint256)": EventFragment;
    "ScriptResult(address,bytes,bytes,bytes)": EventFragment;
    "RecoverToVault(address,address,uint256)": EventFragment;
    "EIP712StETHInitialized(address)": EventFragment;
    "TransferShares(address,address,uint256)": EventFragment;
    "SharesBurnt(address,uint256,uint256,uint256)": EventFragment;
    "Stopped()": EventFragment;
    "Resumed()": EventFragment;
    "Transfer(address,address,uint256)": EventFragment;
    "Approval(address,address,uint256)": EventFragment;
    "ContractVersionSet(uint256)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "StakingPaused"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "StakingResumed"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "StakingLimitSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "StakingLimitRemoved"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "CLValidatorsUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "DepositedValidatorsChanged"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ETHDistributed"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "TokenRebased"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LidoLocatorSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ELRewardsReceived"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "WithdrawalsReceived"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Submitted"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Unbuffered"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ScriptResult"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RecoverToVault"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "EIP712StETHInitialized"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "TransferShares"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SharesBurnt"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Stopped"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Resumed"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ContractVersionSet"): EventFragment;
}

export type StakingPausedEvent = TypedEvent<[] & {}>;

export type StakingResumedEvent = TypedEvent<[] & {}>;

export type StakingLimitSetEvent = TypedEvent<
  [BigNumber, BigNumber] & {
    maxStakeLimit: BigNumber;
    stakeLimitIncreasePerBlock: BigNumber;
  }
>;

export type StakingLimitRemovedEvent = TypedEvent<[] & {}>;

export type CLValidatorsUpdatedEvent = TypedEvent<
  [BigNumber, BigNumber, BigNumber] & {
    reportTimestamp: BigNumber;
    preCLValidators: BigNumber;
    postCLValidators: BigNumber;
  }
>;

export type DepositedValidatorsChangedEvent = TypedEvent<
  [BigNumber] & { depositedValidators: BigNumber }
>;

export type ETHDistributedEvent = TypedEvent<
  [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
    reportTimestamp: BigNumber;
    preCLBalance: BigNumber;
    postCLBalance: BigNumber;
    withdrawalsWithdrawn: BigNumber;
    executionLayerRewardsWithdrawn: BigNumber;
    postBufferedEther: BigNumber;
  }
>;

export type TokenRebasedEvent = TypedEvent<
  [
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber
  ] & {
    reportTimestamp: BigNumber;
    timeElapsed: BigNumber;
    preTotalShares: BigNumber;
    preTotalEther: BigNumber;
    postTotalShares: BigNumber;
    postTotalEther: BigNumber;
    sharesMintedAsFees: BigNumber;
  }
>;

export type LidoLocatorSetEvent = TypedEvent<
  [string] & { lidoLocator: string }
>;

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

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

export type SubmittedEvent = TypedEvent<
  [string, BigNumber, string] & {
    sender: string;
    amount: BigNumber;
    referral: string;
  }
>;

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

export type ScriptResultEvent = TypedEvent<
  [string, string, string, string] & {
    executor: string;
    script: string;
    input: string;
    returnData: string;
  }
>;

export type RecoverToVaultEvent = TypedEvent<
  [string, string, BigNumber] & {
    vault: string;
    token: string;
    amount: BigNumber;
  }
>;

export type EIP712StETHInitializedEvent = TypedEvent<
  [string] & { eip712StETH: string }
>;

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

export type SharesBurntEvent = TypedEvent<
  [string, BigNumber, BigNumber, BigNumber] & {
    account: string;
    preRebaseTokenAmount: BigNumber;
    postRebaseTokenAmount: BigNumber;
    sharesAmount: BigNumber;
  }
>;

export type StoppedEvent = TypedEvent<[] & {}>;

export type ResumedEvent = TypedEvent<[] & {}>;

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

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

export type ContractVersionSetEvent = TypedEvent<
  [BigNumber] & { version: BigNumber }
>;

export class StethAbi 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: StethAbiInterface;

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

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

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

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

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

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

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

    getSharesByPooledEth(
      _ethAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

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

    getEVMScriptExecutor(
      _script: BytesLike,
      overrides?: CallOverrides
    ): Promise<[string]>;

    setStakingLimit(
      _maxStakeLimit: BigNumberish,
      _stakeLimitIncreasePerBlock: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    finalizeUpgrade_v2(
      _lidoLocator: string,
      _eip712StETH: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

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

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

    initialize(
      _lidoLocator: string,
      _eip712StETH: string,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

    getStakeLimitFullInfo(
      overrides?: CallOverrides
    ): Promise<
      [
        boolean,
        boolean,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber
      ] & {
        isStakingPaused: boolean;
        isStakingLimitSet: boolean;
        currentStakeLimit: BigNumber;
        maxStakeLimit: BigNumber;
        maxStakeLimitGrowthBlocks: BigNumber;
        prevStakeLimit: BigNumber;
        prevStakeBlockNumber: BigNumber;
      }
    >;

    transferSharesFrom(
      _sender: string,
      _recipient: string,
      _sharesAmount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

    getFeeDistribution(
      overrides?: CallOverrides
    ): Promise<
      [number, number, number] & {
        treasuryFeeBasisPoints: number;
        insuranceFeeBasisPoints: number;
        operatorsFeeBasisPoints: number;
      }
    >;

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

    getPooledEthByShares(
      _sharesAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

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

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

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

    eip712Domain(
      overrides?: CallOverrides
    ): Promise<
      [string, string, BigNumber, string] & {
        name: string;
        version: string;
        chainId: BigNumber;
        verifyingContract: string;
      }
    >;

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

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

    transferShares(
      _recipient: string,
      _sharesAmount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

    canPerform(
      _sender: string,
      _role: BytesLike,
      _params: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    submit(
      _referral: string,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

    deposit(
      _maxDepositsCount: BigNumberish,
      _stakingModuleId: BigNumberish,
      _depositCalldata: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    getBeaconStat(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber] & {
        depositedValidators: BigNumber;
        beaconValidators: BigNumber;
        beaconBalance: BigNumber;
      }
    >;

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

    handleOracleReport(
      _reportTimestamp: BigNumberish,
      _timeElapsed: BigNumberish,
      _clValidators: BigNumberish,
      _clBalance: BigNumberish,
      _withdrawalVaultBalance: BigNumberish,
      _elRewardsVaultBalance: BigNumberish,
      _sharesRequestedToBurn: BigNumberish,
      _withdrawalFinalizationBatches: BigNumberish[],
      _simulatedShareRate: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    getFee(overrides?: CallOverrides): Promise<[number] & { totalFee: number }>;

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

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

    permit(
      _owner: string,
      _spender: string,
      _value: BigNumberish,
      _deadline: BigNumberish,
      _v: BigNumberish,
      _r: BytesLike,
      _s: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  getSharesByPooledEth(
    _ethAmount: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

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

  getEVMScriptExecutor(
    _script: BytesLike,
    overrides?: CallOverrides
  ): Promise<string>;

  setStakingLimit(
    _maxStakeLimit: BigNumberish,
    _stakeLimitIncreasePerBlock: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  finalizeUpgrade_v2(
    _lidoLocator: string,
    _eip712StETH: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

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

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

  initialize(
    _lidoLocator: string,
    _eip712StETH: string,
    overrides?: PayableOverrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

  getStakeLimitFullInfo(
    overrides?: CallOverrides
  ): Promise<
    [
      boolean,
      boolean,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber
    ] & {
      isStakingPaused: boolean;
      isStakingLimitSet: boolean;
      currentStakeLimit: BigNumber;
      maxStakeLimit: BigNumber;
      maxStakeLimitGrowthBlocks: BigNumber;
      prevStakeLimit: BigNumber;
      prevStakeBlockNumber: BigNumber;
    }
  >;

  transferSharesFrom(
    _sender: string,
    _recipient: string,
    _sharesAmount: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

  getFeeDistribution(
    overrides?: CallOverrides
  ): Promise<
    [number, number, number] & {
      treasuryFeeBasisPoints: number;
      insuranceFeeBasisPoints: number;
      operatorsFeeBasisPoints: number;
    }
  >;

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

  getPooledEthByShares(
    _sharesAmount: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

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

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

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

  eip712Domain(
    overrides?: CallOverrides
  ): Promise<
    [string, string, BigNumber, string] & {
      name: string;
      version: string;
      chainId: BigNumber;
      verifyingContract: string;
    }
  >;

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

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

  transferShares(
    _recipient: string,
    _sharesAmount: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

  canPerform(
    _sender: string,
    _role: BytesLike,
    _params: BigNumberish[],
    overrides?: CallOverrides
  ): Promise<boolean>;

  submit(
    _referral: string,
    overrides?: PayableOverrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

  deposit(
    _maxDepositsCount: BigNumberish,
    _stakingModuleId: BigNumberish,
    _depositCalldata: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  getBeaconStat(
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber, BigNumber] & {
      depositedValidators: BigNumber;
      beaconValidators: BigNumber;
      beaconBalance: BigNumber;
    }
  >;

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

  handleOracleReport(
    _reportTimestamp: BigNumberish,
    _timeElapsed: BigNumberish,
    _clValidators: BigNumberish,
    _clBalance: BigNumberish,
    _withdrawalVaultBalance: BigNumberish,
    _elRewardsVaultBalance: BigNumberish,
    _sharesRequestedToBurn: BigNumberish,
    _withdrawalFinalizationBatches: BigNumberish[],
    _simulatedShareRate: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

  permit(
    _owner: string,
    _spender: string,
    _value: BigNumberish,
    _deadline: BigNumberish,
    _v: BigNumberish,
    _r: BytesLike,
    _s: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  allowance(
    _owner: string,
    _spender: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

  callStatic: {
    resume(overrides?: CallOverrides): Promise<void>;

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

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

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

    approve(
      _spender: string,
      _amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

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

    getSharesByPooledEth(
      _ethAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    transferFrom(
      _sender: string,
      _recipient: string,
      _amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    getEVMScriptExecutor(
      _script: BytesLike,
      overrides?: CallOverrides
    ): Promise<string>;

    setStakingLimit(
      _maxStakeLimit: BigNumberish,
      _stakeLimitIncreasePerBlock: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

    finalizeUpgrade_v2(
      _lidoLocator: string,
      _eip712StETH: string,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

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

    unsafeChangeDepositedValidators(
      _newDepositedValidators: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

    increaseAllowance(
      _spender: string,
      _addedValue: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

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

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

    initialize(
      _lidoLocator: string,
      _eip712StETH: string,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

    getStakeLimitFullInfo(
      overrides?: CallOverrides
    ): Promise<
      [
        boolean,
        boolean,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber
      ] & {
        isStakingPaused: boolean;
        isStakingLimitSet: boolean;
        currentStakeLimit: BigNumber;
        maxStakeLimit: BigNumber;
        maxStakeLimitGrowthBlocks: BigNumber;
        prevStakeLimit: BigNumber;
        prevStakeBlockNumber: BigNumber;
      }
    >;

    transferSharesFrom(
      _sender: string,
      _recipient: string,
      _sharesAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    getFeeDistribution(
      overrides?: CallOverrides
    ): Promise<
      [number, number, number] & {
        treasuryFeeBasisPoints: number;
        insuranceFeeBasisPoints: number;
        operatorsFeeBasisPoints: number;
      }
    >;

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

    getPooledEthByShares(
      _sharesAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

    eip712Domain(
      overrides?: CallOverrides
    ): Promise<
      [string, string, BigNumber, string] & {
        name: string;
        version: string;
        chainId: BigNumber;
        verifyingContract: string;
      }
    >;

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

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

    transferShares(
      _recipient: string,
      _sharesAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

    canPerform(
      _sender: string,
      _role: BytesLike,
      _params: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<boolean>;

    submit(_referral: string, overrides?: CallOverrides): Promise<BigNumber>;

    decreaseAllowance(
      _spender: string,
      _subtractedValue: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

    transfer(
      _recipient: string,
      _amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    deposit(
      _maxDepositsCount: BigNumberish,
      _stakingModuleId: BigNumberish,
      _depositCalldata: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

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

    getBeaconStat(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber] & {
        depositedValidators: BigNumber;
        beaconValidators: BigNumber;
        beaconBalance: BigNumber;
      }
    >;

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

    handleOracleReport(
      _reportTimestamp: BigNumberish,
      _timeElapsed: BigNumberish,
      _clValidators: BigNumberish,
      _clBalance: BigNumberish,
      _withdrawalVaultBalance: BigNumberish,
      _elRewardsVaultBalance: BigNumberish,
      _sharesRequestedToBurn: BigNumberish,
      _withdrawalFinalizationBatches: BigNumberish[],
      _simulatedShareRate: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber, BigNumber, BigNumber, BigNumber]>;

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

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

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

    permit(
      _owner: string,
      _spender: string,
      _value: BigNumberish,
      _deadline: BigNumberish,
      _v: BigNumberish,
      _r: BytesLike,
      _s: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

    allowance(
      _owner: string,
      _spender: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

  filters: {
    "StakingPaused()"(): TypedEventFilter<[], {}>;

    StakingPaused(): TypedEventFilter<[], {}>;

    "StakingResumed()"(): TypedEventFilter<[], {}>;

    StakingResumed(): TypedEventFilter<[], {}>;

    "StakingLimitSet(uint256,uint256)"(
      maxStakeLimit?: null,
      stakeLimitIncreasePerBlock?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber],
      { maxStakeLimit: BigNumber; stakeLimitIncreasePerBlock: BigNumber }
    >;

    StakingLimitSet(
      maxStakeLimit?: null,
      stakeLimitIncreasePerBlock?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber],
      { maxStakeLimit: BigNumber; stakeLimitIncreasePerBlock: BigNumber }
    >;

    "StakingLimitRemoved()"(): TypedEventFilter<[], {}>;

    StakingLimitRemoved(): TypedEventFilter<[], {}>;

    "CLValidatorsUpdated(uint256,uint256,uint256)"(
      reportTimestamp?: BigNumberish | null,
      preCLValidators?: null,
      postCLValidators?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber, BigNumber],
      {
        reportTimestamp: BigNumber;
        preCLValidators: BigNumber;
        postCLValidators: BigNumber;
      }
    >;

    CLValidatorsUpdated(
      reportTimestamp?: BigNumberish | null,
      preCLValidators?: null,
      postCLValidators?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber, BigNumber],
      {
        reportTimestamp: BigNumber;
        preCLValidators: BigNumber;
        postCLValidators: BigNumber;
      }
    >;

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

    DepositedValidatorsChanged(
      depositedValidators?: null
    ): TypedEventFilter<[BigNumber], { depositedValidators: BigNumber }>;

    "ETHDistributed(uint256,uint256,uint256,uint256,uint256,uint256)"(
      reportTimestamp?: BigNumberish | null,
      preCLBalance?: null,
      postCLBalance?: null,
      withdrawalsWithdrawn?: null,
      executionLayerRewardsWithdrawn?: null,
      postBufferedEther?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber, BigNumber],
      {
        reportTimestamp: BigNumber;
        preCLBalance: BigNumber;
        postCLBalance: BigNumber;
        withdrawalsWithdrawn: BigNumber;
        executionLayerRewardsWithdrawn: BigNumber;
        postBufferedEther: BigNumber;
      }
    >;

    ETHDistributed(
      reportTimestamp?: BigNumberish | null,
      preCLBalance?: null,
      postCLBalance?: null,
      withdrawalsWithdrawn?: null,
      executionLayerRewardsWithdrawn?: null,
      postBufferedEther?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber, BigNumber],
      {
        reportTimestamp: BigNumber;
        preCLBalance: BigNumber;
        postCLBalance: BigNumber;
        withdrawalsWithdrawn: BigNumber;
        executionLayerRewardsWithdrawn: BigNumber;
        postBufferedEther: BigNumber;
      }
    >;

    "TokenRebased(uint256,uint256,uint256,uint256,uint256,uint256,uint256)"(
      reportTimestamp?: BigNumberish | null,
      timeElapsed?: null,
      preTotalShares?: null,
      preTotalEther?: null,
      postTotalShares?: null,
      postTotalEther?: null,
      sharesMintedAsFees?: null
    ): TypedEventFilter<
      [
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber
      ],
      {
        reportTimestamp: BigNumber;
        timeElapsed: BigNumber;
        preTotalShares: BigNumber;
        preTotalEther: BigNumber;
        postTotalShares: BigNumber;
        postTotalEther: BigNumber;
        sharesMintedAsFees: BigNumber;
      }
    >;

    TokenRebased(
      reportTimestamp?: BigNumberish | null,
      timeElapsed?: null,
      preTotalShares?: null,
      preTotalEther?: null,
      postTotalShares?: null,
      postTotalEther?: null,
      sharesMintedAsFees?: null
    ): TypedEventFilter<
      [
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber
      ],
      {
        reportTimestamp: BigNumber;
        timeElapsed: BigNumber;
        preTotalShares: BigNumber;
        preTotalEther: BigNumber;
        postTotalShares: BigNumber;
        postTotalEther: BigNumber;
        sharesMintedAsFees: BigNumber;
      }
    >;

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

    LidoLocatorSet(
      lidoLocator?: null
    ): TypedEventFilter<[string], { lidoLocator: string }>;

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

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

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

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

    "Submitted(address,uint256,address)"(
      sender?: string | null,
      amount?: null,
      referral?: null
    ): TypedEventFilter<
      [string, BigNumber, string],
      { sender: string; amount: BigNumber; referral: string }
    >;

    Submitted(
      sender?: string | null,
      amount?: null,
      referral?: null
    ): TypedEventFilter<
      [string, BigNumber, string],
      { sender: string; amount: BigNumber; referral: string }
    >;

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

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

    "ScriptResult(address,bytes,bytes,bytes)"(
      executor?: string | null,
      script?: null,
      input?: null,
      returnData?: null
    ): TypedEventFilter<
      [string, string, string, string],
      { executor: string; script: string; input: string; returnData: string }
    >;

    ScriptResult(
      executor?: string | null,
      script?: null,
      input?: null,
      returnData?: null
    ): TypedEventFilter<
      [string, string, string, string],
      { executor: string; script: string; input: string; returnData: string }
    >;

    "RecoverToVault(address,address,uint256)"(
      vault?: string | null,
      token?: string | null,
      amount?: null
    ): TypedEventFilter<
      [string, string, BigNumber],
      { vault: string; token: string; amount: BigNumber }
    >;

    RecoverToVault(
      vault?: string | null,
      token?: string | null,
      amount?: null
    ): TypedEventFilter<
      [string, string, BigNumber],
      { vault: string; token: string; amount: BigNumber }
    >;

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

    EIP712StETHInitialized(
      eip712StETH?: null
    ): TypedEventFilter<[string], { eip712StETH: string }>;

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

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

    "SharesBurnt(address,uint256,uint256,uint256)"(
      account?: string | null,
      preRebaseTokenAmount?: null,
      postRebaseTokenAmount?: null,
      sharesAmount?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber, BigNumber],
      {
        account: string;
        preRebaseTokenAmount: BigNumber;
        postRebaseTokenAmount: BigNumber;
        sharesAmount: BigNumber;
      }
    >;

    SharesBurnt(
      account?: string | null,
      preRebaseTokenAmount?: null,
      postRebaseTokenAmount?: null,
      sharesAmount?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber, BigNumber],
      {
        account: string;
        preRebaseTokenAmount: BigNumber;
        postRebaseTokenAmount: BigNumber;
        sharesAmount: BigNumber;
      }
    >;

    "Stopped()"(): TypedEventFilter<[], {}>;

    Stopped(): TypedEventFilter<[], {}>;

    "Resumed()"(): TypedEventFilter<[], {}>;

    Resumed(): TypedEventFilter<[], {}>;

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

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

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

    ContractVersionSet(
      version?: null
    ): TypedEventFilter<[BigNumber], { version: BigNumber }>;
  };

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

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

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

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

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

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

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

    getSharesByPooledEth(
      _ethAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    getEVMScriptExecutor(
      _script: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    setStakingLimit(
      _maxStakeLimit: BigNumberish,
      _stakeLimitIncreasePerBlock: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    finalizeUpgrade_v2(
      _lidoLocator: string,
      _eip712StETH: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

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

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

    initialize(
      _lidoLocator: string,
      _eip712StETH: string,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

    transferSharesFrom(
      _sender: string,
      _recipient: string,
      _sharesAmount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

    getPooledEthByShares(
      _sharesAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

    transferShares(
      _recipient: string,
      _sharesAmount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

    canPerform(
      _sender: string,
      _role: BytesLike,
      _params: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    submit(
      _referral: string,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

    deposit(
      _maxDepositsCount: BigNumberish,
      _stakingModuleId: BigNumberish,
      _depositCalldata: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

    handleOracleReport(
      _reportTimestamp: BigNumberish,
      _timeElapsed: BigNumberish,
      _clValidators: BigNumberish,
      _clBalance: BigNumberish,
      _withdrawalVaultBalance: BigNumberish,
      _elRewardsVaultBalance: BigNumberish,
      _sharesRequestedToBurn: BigNumberish,
      _withdrawalFinalizationBatches: BigNumberish[],
      _simulatedShareRate: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

    permit(
      _owner: string,
      _spender: string,
      _value: BigNumberish,
      _deadline: BigNumberish,
      _v: BigNumberish,
      _r: BytesLike,
      _s: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    allowance(
      _owner: string,
      _spender: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    getSharesByPooledEth(
      _ethAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    getEVMScriptExecutor(
      _script: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    setStakingLimit(
      _maxStakeLimit: BigNumberish,
      _stakeLimitIncreasePerBlock: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    finalizeUpgrade_v2(
      _lidoLocator: string,
      _eip712StETH: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

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

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

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

    initialize(
      _lidoLocator: string,
      _eip712StETH: string,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

    transferSharesFrom(
      _sender: string,
      _recipient: string,
      _sharesAmount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

    getPooledEthByShares(
      _sharesAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

    transferShares(
      _recipient: string,
      _sharesAmount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

    canPerform(
      _sender: string,
      _role: BytesLike,
      _params: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    submit(
      _referral: string,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

    deposit(
      _maxDepositsCount: BigNumberish,
      _stakingModuleId: BigNumberish,
      _depositCalldata: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

    handleOracleReport(
      _reportTimestamp: BigNumberish,
      _timeElapsed: BigNumberish,
      _clValidators: BigNumberish,
      _clBalance: BigNumberish,
      _withdrawalVaultBalance: BigNumberish,
      _elRewardsVaultBalance: BigNumberish,
      _sharesRequestedToBurn: BigNumberish,
      _withdrawalFinalizationBatches: BigNumberish[],
      _simulatedShareRate: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

    permit(
      _owner: string,
      _spender: string,
      _value: BigNumberish,
      _deadline: BigNumberish,
      _v: BigNumberish,
      _r: BytesLike,
      _s: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    allowance(
      _owner: string,
      _spender: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

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