@towns-protocol/generated/dev/typings/RewardsDistributionV2.ts

## How to generate contract types

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

export declare namespace StakingRewards {
  export type DepositStruct = {
    amount: PromiseOrValue<BigNumberish>;
    owner: PromiseOrValue<string>;
    commissionEarningPower: PromiseOrValue<BigNumberish>;
    delegatee: PromiseOrValue<string>;
    pendingWithdrawal: PromiseOrValue<BigNumberish>;
    beneficiary: PromiseOrValue<string>;
  };

  export type DepositStructOutput = [
    BigNumber,
    string,
    BigNumber,
    string,
    BigNumber,
    string
  ] & {
    amount: BigNumber;
    owner: string;
    commissionEarningPower: BigNumber;
    delegatee: string;
    pendingWithdrawal: BigNumber;
    beneficiary: string;
  };

  export type TreasureStruct = {
    earningPower: PromiseOrValue<BigNumberish>;
    rewardPerTokenAccumulated: PromiseOrValue<BigNumberish>;
    unclaimedRewardSnapshot: PromiseOrValue<BigNumberish>;
  };

  export type TreasureStructOutput = [BigNumber, BigNumber, BigNumber] & {
    earningPower: BigNumber;
    rewardPerTokenAccumulated: BigNumber;
    unclaimedRewardSnapshot: BigNumber;
  };
}

export declare namespace IRewardsDistributionBase {
  export type StakingStateStruct = {
    riverToken: PromiseOrValue<string>;
    totalStaked: PromiseOrValue<BigNumberish>;
    rewardDuration: PromiseOrValue<BigNumberish>;
    rewardEndTime: PromiseOrValue<BigNumberish>;
    lastUpdateTime: PromiseOrValue<BigNumberish>;
    rewardRate: PromiseOrValue<BigNumberish>;
    rewardPerTokenAccumulated: PromiseOrValue<BigNumberish>;
    nextDepositId: PromiseOrValue<BigNumberish>;
  };

  export type StakingStateStructOutput = [
    string,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber
  ] & {
    riverToken: string;
    totalStaked: BigNumber;
    rewardDuration: BigNumber;
    rewardEndTime: BigNumber;
    lastUpdateTime: BigNumber;
    rewardRate: BigNumber;
    rewardPerTokenAccumulated: BigNumber;
    nextDepositId: BigNumber;
  };
}

export interface RewardsDistributionV2Interface extends utils.Interface {
  functions: {
    "__RewardsDistribution_init(address,address,uint256)": FunctionFragment;
    "changeBeneficiary(uint256,address)": FunctionFragment;
    "claimReward(address,address)": FunctionFragment;
    "currentReward(address)": FunctionFragment;
    "currentRewardPerTokenAccumulated()": FunctionFragment;
    "currentSpaceDelegationReward(address)": FunctionFragment;
    "delegationProxyById(uint256)": FunctionFragment;
    "depositById(uint256)": FunctionFragment;
    "getDepositsByDepositor(address)": FunctionFragment;
    "getPeriodRewardAmount()": FunctionFragment;
    "implementation()": FunctionFragment;
    "increaseStake(uint256,uint96)": FunctionFragment;
    "initiateWithdraw(uint256)": FunctionFragment;
    "isRewardNotifier(address)": FunctionFragment;
    "lastTimeRewardDistributed()": FunctionFragment;
    "notifyRewardAmount(uint256)": FunctionFragment;
    "permitAndIncreaseStake(uint256,uint96,uint256,uint256,bytes)": FunctionFragment;
    "permitAndStake(uint96,address,address,uint256,uint256,bytes)": FunctionFragment;
    "redelegate(uint256,address)": FunctionFragment;
    "setPeriodRewardAmount(uint256)": FunctionFragment;
    "setRewardNotifier(address,bool)": FunctionFragment;
    "stake(uint96,address,address)": FunctionFragment;
    "stakeOnBehalf(uint96,address,address,address,uint256,bytes)": FunctionFragment;
    "stakedByDepositor(address)": FunctionFragment;
    "stakingState()": FunctionFragment;
    "treasureByBeneficiary(address)": FunctionFragment;
    "upgradeDelegationProxy(address)": FunctionFragment;
    "withdraw(uint256)": FunctionFragment;
  };

  getFunction(
    nameOrSignatureOrTopic:
      | "__RewardsDistribution_init"
      | "changeBeneficiary"
      | "claimReward"
      | "currentReward"
      | "currentRewardPerTokenAccumulated"
      | "currentSpaceDelegationReward"
      | "delegationProxyById"
      | "depositById"
      | "getDepositsByDepositor"
      | "getPeriodRewardAmount"
      | "implementation"
      | "increaseStake"
      | "initiateWithdraw"
      | "isRewardNotifier"
      | "lastTimeRewardDistributed"
      | "notifyRewardAmount"
      | "permitAndIncreaseStake"
      | "permitAndStake"
      | "redelegate"
      | "setPeriodRewardAmount"
      | "setRewardNotifier"
      | "stake"
      | "stakeOnBehalf"
      | "stakedByDepositor"
      | "stakingState"
      | "treasureByBeneficiary"
      | "upgradeDelegationProxy"
      | "withdraw"
  ): FunctionFragment;

  encodeFunctionData(
    functionFragment: "__RewardsDistribution_init",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "changeBeneficiary",
    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "claimReward",
    values: [PromiseOrValue<string>, PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "currentReward",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "currentRewardPerTokenAccumulated",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "currentSpaceDelegationReward",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "delegationProxyById",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "depositById",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "getDepositsByDepositor",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "getPeriodRewardAmount",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "implementation",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "increaseStake",
    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "initiateWithdraw",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "isRewardNotifier",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "lastTimeRewardDistributed",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "notifyRewardAmount",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "permitAndIncreaseStake",
    values: [
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BytesLike>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "permitAndStake",
    values: [
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BytesLike>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "redelegate",
    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "setPeriodRewardAmount",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "setRewardNotifier",
    values: [PromiseOrValue<string>, PromiseOrValue<boolean>]
  ): string;
  encodeFunctionData(
    functionFragment: "stake",
    values: [
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<string>,
      PromiseOrValue<string>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "stakeOnBehalf",
    values: [
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BytesLike>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "stakedByDepositor",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "stakingState",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "treasureByBeneficiary",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "upgradeDelegationProxy",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "withdraw",
    values: [PromiseOrValue<BigNumberish>]
  ): string;

  decodeFunctionResult(
    functionFragment: "__RewardsDistribution_init",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "changeBeneficiary",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "claimReward",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "currentReward",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "currentRewardPerTokenAccumulated",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "currentSpaceDelegationReward",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "delegationProxyById",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "depositById",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getDepositsByDepositor",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getPeriodRewardAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "implementation",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "increaseStake",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "initiateWithdraw",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isRewardNotifier",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "lastTimeRewardDistributed",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "notifyRewardAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "permitAndIncreaseStake",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "permitAndStake",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "redelegate", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setPeriodRewardAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setRewardNotifier",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "stake", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "stakeOnBehalf",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "stakedByDepositor",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "stakingState",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "treasureByBeneficiary",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "upgradeDelegationProxy",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;

  events: {
    "ChangeBeneficiary(uint256,address)": EventFragment;
    "ClaimReward(address,address,uint256)": EventFragment;
    "ClaimerSet(address,address)": EventFragment;
    "CrossDomainMessengerSet(address)": EventFragment;
    "DelegationDigestSet(bytes32)": EventFragment;
    "DelegationProxyDeployed(uint256,address,address)": EventFragment;
    "DelegationRemoved(address)": EventFragment;
    "DelegationSet(address,address,uint256)": EventFragment;
    "IncreaseStake(uint256,uint96)": EventFragment;
    "Initialized(uint32)": EventFragment;
    "InitiateWithdraw(address,uint256,uint96)": EventFragment;
    "InterfaceAdded(bytes4)": EventFragment;
    "InterfaceRemoved(bytes4)": EventFragment;
    "NotifyRewardAmount(address,uint256)": EventFragment;
    "OwnershipTransferred(address,address)": EventFragment;
    "PeriodRewardAmountSet(uint256)": EventFragment;
    "ProxyDelegationSet(address)": EventFragment;
    "Redelegate(uint256,address)": EventFragment;
    "RewardNotifierSet(address,bool)": EventFragment;
    "RewardsDistributionInitialized(address,address,uint256)": EventFragment;
    "SpaceRewardsSwept(address,address,uint256)": EventFragment;
    "Stake(address,address,address,uint256,uint96)": EventFragment;
    "Upgraded(address)": EventFragment;
    "Withdraw(uint256,uint96)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "ChangeBeneficiary"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ClaimReward"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ClaimerSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "CrossDomainMessengerSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "DelegationDigestSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "DelegationProxyDeployed"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "DelegationRemoved"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "DelegationSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "IncreaseStake"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "InitiateWithdraw"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "InterfaceAdded"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "InterfaceRemoved"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NotifyRewardAmount"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "PeriodRewardAmountSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ProxyDelegationSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Redelegate"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RewardNotifierSet"): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "RewardsDistributionInitialized"
  ): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SpaceRewardsSwept"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Stake"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Upgraded"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Withdraw"): EventFragment;
}

export interface ChangeBeneficiaryEventObject {
  depositId: BigNumber;
  newBeneficiary: string;
}
export type ChangeBeneficiaryEvent = TypedEvent<
  [BigNumber, string],
  ChangeBeneficiaryEventObject
>;

export type ChangeBeneficiaryEventFilter =
  TypedEventFilter<ChangeBeneficiaryEvent>;

export interface ClaimRewardEventObject {
  beneficiary: string;
  recipient: string;
  reward: BigNumber;
}
export type ClaimRewardEvent = TypedEvent<
  [string, string, BigNumber],
  ClaimRewardEventObject
>;

export type ClaimRewardEventFilter = TypedEventFilter<ClaimRewardEvent>;

export interface ClaimerSetEventObject {
  delegator: string;
  claimer: string;
}
export type ClaimerSetEvent = TypedEvent<
  [string, string],
  ClaimerSetEventObject
>;

export type ClaimerSetEventFilter = TypedEventFilter<ClaimerSetEvent>;

export interface CrossDomainMessengerSetEventObject {
  messenger: string;
}
export type CrossDomainMessengerSetEvent = TypedEvent<
  [string],
  CrossDomainMessengerSetEventObject
>;

export type CrossDomainMessengerSetEventFilter =
  TypedEventFilter<CrossDomainMessengerSetEvent>;

export interface DelegationDigestSetEventObject {
  digest: string;
}
export type DelegationDigestSetEvent = TypedEvent<
  [string],
  DelegationDigestSetEventObject
>;

export type DelegationDigestSetEventFilter =
  TypedEventFilter<DelegationDigestSetEvent>;

export interface DelegationProxyDeployedEventObject {
  depositId: BigNumber;
  delegatee: string;
  proxy: string;
}
export type DelegationProxyDeployedEvent = TypedEvent<
  [BigNumber, string, string],
  DelegationProxyDeployedEventObject
>;

export type DelegationProxyDeployedEventFilter =
  TypedEventFilter<DelegationProxyDeployedEvent>;

export interface DelegationRemovedEventObject {
  delegator: string;
}
export type DelegationRemovedEvent = TypedEvent<
  [string],
  DelegationRemovedEventObject
>;

export type DelegationRemovedEventFilter =
  TypedEventFilter<DelegationRemovedEvent>;

export interface DelegationSetEventObject {
  delegator: string;
  operator: string;
  quantity: BigNumber;
}
export type DelegationSetEvent = TypedEvent<
  [string, string, BigNumber],
  DelegationSetEventObject
>;

export type DelegationSetEventFilter = TypedEventFilter<DelegationSetEvent>;

export interface IncreaseStakeEventObject {
  depositId: BigNumber;
  amount: BigNumber;
}
export type IncreaseStakeEvent = TypedEvent<
  [BigNumber, BigNumber],
  IncreaseStakeEventObject
>;

export type IncreaseStakeEventFilter = TypedEventFilter<IncreaseStakeEvent>;

export interface InitializedEventObject {
  version: number;
}
export type InitializedEvent = TypedEvent<[number], InitializedEventObject>;

export type InitializedEventFilter = TypedEventFilter<InitializedEvent>;

export interface InitiateWithdrawEventObject {
  owner: string;
  depositId: BigNumber;
  amount: BigNumber;
}
export type InitiateWithdrawEvent = TypedEvent<
  [string, BigNumber, BigNumber],
  InitiateWithdrawEventObject
>;

export type InitiateWithdrawEventFilter =
  TypedEventFilter<InitiateWithdrawEvent>;

export interface InterfaceAddedEventObject {
  interfaceId: string;
}
export type InterfaceAddedEvent = TypedEvent<
  [string],
  InterfaceAddedEventObject
>;

export type InterfaceAddedEventFilter = TypedEventFilter<InterfaceAddedEvent>;

export interface InterfaceRemovedEventObject {
  interfaceId: string;
}
export type InterfaceRemovedEvent = TypedEvent<
  [string],
  InterfaceRemovedEventObject
>;

export type InterfaceRemovedEventFilter =
  TypedEventFilter<InterfaceRemovedEvent>;

export interface NotifyRewardAmountEventObject {
  notifier: string;
  reward: BigNumber;
}
export type NotifyRewardAmountEvent = TypedEvent<
  [string, BigNumber],
  NotifyRewardAmountEventObject
>;

export type NotifyRewardAmountEventFilter =
  TypedEventFilter<NotifyRewardAmountEvent>;

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

export type OwnershipTransferredEventFilter =
  TypedEventFilter<OwnershipTransferredEvent>;

export interface PeriodRewardAmountSetEventObject {
  amount: BigNumber;
}
export type PeriodRewardAmountSetEvent = TypedEvent<
  [BigNumber],
  PeriodRewardAmountSetEventObject
>;

export type PeriodRewardAmountSetEventFilter =
  TypedEventFilter<PeriodRewardAmountSetEvent>;

export interface ProxyDelegationSetEventObject {
  proxyDelegation: string;
}
export type ProxyDelegationSetEvent = TypedEvent<
  [string],
  ProxyDelegationSetEventObject
>;

export type ProxyDelegationSetEventFilter =
  TypedEventFilter<ProxyDelegationSetEvent>;

export interface RedelegateEventObject {
  depositId: BigNumber;
  delegatee: string;
}
export type RedelegateEvent = TypedEvent<
  [BigNumber, string],
  RedelegateEventObject
>;

export type RedelegateEventFilter = TypedEventFilter<RedelegateEvent>;

export interface RewardNotifierSetEventObject {
  notifier: string;
  enabled: boolean;
}
export type RewardNotifierSetEvent = TypedEvent<
  [string, boolean],
  RewardNotifierSetEventObject
>;

export type RewardNotifierSetEventFilter =
  TypedEventFilter<RewardNotifierSetEvent>;

export interface RewardsDistributionInitializedEventObject {
  stakeToken: string;
  rewardToken: string;
  rewardDuration: BigNumber;
}
export type RewardsDistributionInitializedEvent = TypedEvent<
  [string, string, BigNumber],
  RewardsDistributionInitializedEventObject
>;

export type RewardsDistributionInitializedEventFilter =
  TypedEventFilter<RewardsDistributionInitializedEvent>;

export interface SpaceRewardsSweptEventObject {
  space: string;
  operator: string;
  scaledReward: BigNumber;
}
export type SpaceRewardsSweptEvent = TypedEvent<
  [string, string, BigNumber],
  SpaceRewardsSweptEventObject
>;

export type SpaceRewardsSweptEventFilter =
  TypedEventFilter<SpaceRewardsSweptEvent>;

export interface StakeEventObject {
  owner: string;
  delegatee: string;
  beneficiary: string;
  depositId: BigNumber;
  amount: BigNumber;
}
export type StakeEvent = TypedEvent<
  [string, string, string, BigNumber, BigNumber],
  StakeEventObject
>;

export type StakeEventFilter = TypedEventFilter<StakeEvent>;

export interface UpgradedEventObject {
  implementation: string;
}
export type UpgradedEvent = TypedEvent<[string], UpgradedEventObject>;

export type UpgradedEventFilter = TypedEventFilter<UpgradedEvent>;

export interface WithdrawEventObject {
  depositId: BigNumber;
  amount: BigNumber;
}
export type WithdrawEvent = TypedEvent<
  [BigNumber, BigNumber],
  WithdrawEventObject
>;

export type WithdrawEventFilter = TypedEventFilter<WithdrawEvent>;

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

  interface: RewardsDistributionV2Interface;

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

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

  functions: {
    __RewardsDistribution_init(
      stakeToken: PromiseOrValue<string>,
      rewardToken: PromiseOrValue<string>,
      rewardDuration: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    changeBeneficiary(
      depositId: PromiseOrValue<BigNumberish>,
      newBeneficiary: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    claimReward(
      beneficiary: PromiseOrValue<string>,
      recipient: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    currentReward(
      beneficiary: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

    currentSpaceDelegationReward(
      operator: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    delegationProxyById(
      depositId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[string]>;

    depositById(
      depositId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<
      [StakingRewards.DepositStructOutput] & {
        deposit: StakingRewards.DepositStructOutput;
      }
    >;

    getDepositsByDepositor(
      depositor: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[BigNumber[]]>;

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

    implementation(
      overrides?: CallOverrides
    ): Promise<[string] & { result: string }>;

    increaseStake(
      depositId: PromiseOrValue<BigNumberish>,
      amount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    initiateWithdraw(
      depositId: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    isRewardNotifier(
      notifier: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

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

    notifyRewardAmount(
      reward: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    permitAndIncreaseStake(
      depositId: PromiseOrValue<BigNumberish>,
      amount: PromiseOrValue<BigNumberish>,
      nonce: PromiseOrValue<BigNumberish>,
      deadline: PromiseOrValue<BigNumberish>,
      signature: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    permitAndStake(
      amount: PromiseOrValue<BigNumberish>,
      delegatee: PromiseOrValue<string>,
      beneficiary: PromiseOrValue<string>,
      nonce: PromiseOrValue<BigNumberish>,
      deadline: PromiseOrValue<BigNumberish>,
      signature: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    redelegate(
      depositId: PromiseOrValue<BigNumberish>,
      delegatee: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setPeriodRewardAmount(
      amount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setRewardNotifier(
      notifier: PromiseOrValue<string>,
      enabled: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    stake(
      amount: PromiseOrValue<BigNumberish>,
      delegatee: PromiseOrValue<string>,
      beneficiary: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    stakeOnBehalf(
      amount: PromiseOrValue<BigNumberish>,
      delegatee: PromiseOrValue<string>,
      beneficiary: PromiseOrValue<string>,
      owner: PromiseOrValue<string>,
      arg4: PromiseOrValue<BigNumberish>,
      arg5: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    stakedByDepositor(
      depositor: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { amount: BigNumber }>;

    stakingState(
      overrides?: CallOverrides
    ): Promise<
      [IRewardsDistributionBase.StakingStateStructOutput] & {
        state: IRewardsDistributionBase.StakingStateStructOutput;
      }
    >;

    treasureByBeneficiary(
      beneficiary: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<
      [StakingRewards.TreasureStructOutput] & {
        treasure: StakingRewards.TreasureStructOutput;
      }
    >;

    upgradeDelegationProxy(
      newImplementation: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    withdraw(
      depositId: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;
  };

  __RewardsDistribution_init(
    stakeToken: PromiseOrValue<string>,
    rewardToken: PromiseOrValue<string>,
    rewardDuration: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  changeBeneficiary(
    depositId: PromiseOrValue<BigNumberish>,
    newBeneficiary: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  claimReward(
    beneficiary: PromiseOrValue<string>,
    recipient: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  currentReward(
    beneficiary: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

  currentSpaceDelegationReward(
    operator: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  delegationProxyById(
    depositId: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<string>;

  depositById(
    depositId: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<StakingRewards.DepositStructOutput>;

  getDepositsByDepositor(
    depositor: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<BigNumber[]>;

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

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

  increaseStake(
    depositId: PromiseOrValue<BigNumberish>,
    amount: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  initiateWithdraw(
    depositId: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  isRewardNotifier(
    notifier: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<boolean>;

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

  notifyRewardAmount(
    reward: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  permitAndIncreaseStake(
    depositId: PromiseOrValue<BigNumberish>,
    amount: PromiseOrValue<BigNumberish>,
    nonce: PromiseOrValue<BigNumberish>,
    deadline: PromiseOrValue<BigNumberish>,
    signature: PromiseOrValue<BytesLike>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  permitAndStake(
    amount: PromiseOrValue<BigNumberish>,
    delegatee: PromiseOrValue<string>,
    beneficiary: PromiseOrValue<string>,
    nonce: PromiseOrValue<BigNumberish>,
    deadline: PromiseOrValue<BigNumberish>,
    signature: PromiseOrValue<BytesLike>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  redelegate(
    depositId: PromiseOrValue<BigNumberish>,
    delegatee: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setPeriodRewardAmount(
    amount: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setRewardNotifier(
    notifier: PromiseOrValue<string>,
    enabled: PromiseOrValue<boolean>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  stake(
    amount: PromiseOrValue<BigNumberish>,
    delegatee: PromiseOrValue<string>,
    beneficiary: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  stakeOnBehalf(
    amount: PromiseOrValue<BigNumberish>,
    delegatee: PromiseOrValue<string>,
    beneficiary: PromiseOrValue<string>,
    owner: PromiseOrValue<string>,
    arg4: PromiseOrValue<BigNumberish>,
    arg5: PromiseOrValue<BytesLike>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  stakedByDepositor(
    depositor: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  stakingState(
    overrides?: CallOverrides
  ): Promise<IRewardsDistributionBase.StakingStateStructOutput>;

  treasureByBeneficiary(
    beneficiary: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<StakingRewards.TreasureStructOutput>;

  upgradeDelegationProxy(
    newImplementation: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  withdraw(
    depositId: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  callStatic: {
    __RewardsDistribution_init(
      stakeToken: PromiseOrValue<string>,
      rewardToken: PromiseOrValue<string>,
      rewardDuration: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    changeBeneficiary(
      depositId: PromiseOrValue<BigNumberish>,
      newBeneficiary: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    claimReward(
      beneficiary: PromiseOrValue<string>,
      recipient: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    currentReward(
      beneficiary: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    currentSpaceDelegationReward(
      operator: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    delegationProxyById(
      depositId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<string>;

    depositById(
      depositId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<StakingRewards.DepositStructOutput>;

    getDepositsByDepositor(
      depositor: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber[]>;

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

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

    increaseStake(
      depositId: PromiseOrValue<BigNumberish>,
      amount: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    initiateWithdraw(
      depositId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    isRewardNotifier(
      notifier: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

    notifyRewardAmount(
      reward: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    permitAndIncreaseStake(
      depositId: PromiseOrValue<BigNumberish>,
      amount: PromiseOrValue<BigNumberish>,
      nonce: PromiseOrValue<BigNumberish>,
      deadline: PromiseOrValue<BigNumberish>,
      signature: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<void>;

    permitAndStake(
      amount: PromiseOrValue<BigNumberish>,
      delegatee: PromiseOrValue<string>,
      beneficiary: PromiseOrValue<string>,
      nonce: PromiseOrValue<BigNumberish>,
      deadline: PromiseOrValue<BigNumberish>,
      signature: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    redelegate(
      depositId: PromiseOrValue<BigNumberish>,
      delegatee: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    setPeriodRewardAmount(
      amount: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    setRewardNotifier(
      notifier: PromiseOrValue<string>,
      enabled: PromiseOrValue<boolean>,
      overrides?: CallOverrides
    ): Promise<void>;

    stake(
      amount: PromiseOrValue<BigNumberish>,
      delegatee: PromiseOrValue<string>,
      beneficiary: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    stakeOnBehalf(
      amount: PromiseOrValue<BigNumberish>,
      delegatee: PromiseOrValue<string>,
      beneficiary: PromiseOrValue<string>,
      owner: PromiseOrValue<string>,
      arg4: PromiseOrValue<BigNumberish>,
      arg5: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    stakedByDepositor(
      depositor: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    stakingState(
      overrides?: CallOverrides
    ): Promise<IRewardsDistributionBase.StakingStateStructOutput>;

    treasureByBeneficiary(
      beneficiary: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<StakingRewards.TreasureStructOutput>;

    upgradeDelegationProxy(
      newImplementation: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    withdraw(
      depositId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;
  };

  filters: {
    "ChangeBeneficiary(uint256,address)"(
      depositId?: PromiseOrValue<BigNumberish> | null,
      newBeneficiary?: PromiseOrValue<string> | null
    ): ChangeBeneficiaryEventFilter;
    ChangeBeneficiary(
      depositId?: PromiseOrValue<BigNumberish> | null,
      newBeneficiary?: PromiseOrValue<string> | null
    ): ChangeBeneficiaryEventFilter;

    "ClaimReward(address,address,uint256)"(
      beneficiary?: PromiseOrValue<string> | null,
      recipient?: PromiseOrValue<string> | null,
      reward?: null
    ): ClaimRewardEventFilter;
    ClaimReward(
      beneficiary?: PromiseOrValue<string> | null,
      recipient?: PromiseOrValue<string> | null,
      reward?: null
    ): ClaimRewardEventFilter;

    "ClaimerSet(address,address)"(
      delegator?: PromiseOrValue<string> | null,
      claimer?: PromiseOrValue<string> | null
    ): ClaimerSetEventFilter;
    ClaimerSet(
      delegator?: PromiseOrValue<string> | null,
      claimer?: PromiseOrValue<string> | null
    ): ClaimerSetEventFilter;

    "CrossDomainMessengerSet(address)"(
      messenger?: null
    ): CrossDomainMessengerSetEventFilter;
    CrossDomainMessengerSet(
      messenger?: null
    ): CrossDomainMessengerSetEventFilter;

    "DelegationDigestSet(bytes32)"(
      digest?: null
    ): DelegationDigestSetEventFilter;
    DelegationDigestSet(digest?: null): DelegationDigestSetEventFilter;

    "DelegationProxyDeployed(uint256,address,address)"(
      depositId?: PromiseOrValue<BigNumberish> | null,
      delegatee?: PromiseOrValue<string> | null,
      proxy?: null
    ): DelegationProxyDeployedEventFilter;
    DelegationProxyDeployed(
      depositId?: PromiseOrValue<BigNumberish> | null,
      delegatee?: PromiseOrValue<string> | null,
      proxy?: null
    ): DelegationProxyDeployedEventFilter;

    "DelegationRemoved(address)"(
      delegator?: PromiseOrValue<string> | null
    ): DelegationRemovedEventFilter;
    DelegationRemoved(
      delegator?: PromiseOrValue<string> | null
    ): DelegationRemovedEventFilter;

    "DelegationSet(address,address,uint256)"(
      delegator?: PromiseOrValue<string> | null,
      operator?: PromiseOrValue<string> | null,
      quantity?: null
    ): DelegationSetEventFilter;
    DelegationSet(
      delegator?: PromiseOrValue<string> | null,
      operator?: PromiseOrValue<string> | null,
      quantity?: null
    ): DelegationSetEventFilter;

    "IncreaseStake(uint256,uint96)"(
      depositId?: PromiseOrValue<BigNumberish> | null,
      amount?: null
    ): IncreaseStakeEventFilter;
    IncreaseStake(
      depositId?: PromiseOrValue<BigNumberish> | null,
      amount?: null
    ): IncreaseStakeEventFilter;

    "Initialized(uint32)"(version?: null): InitializedEventFilter;
    Initialized(version?: null): InitializedEventFilter;

    "InitiateWithdraw(address,uint256,uint96)"(
      owner?: PromiseOrValue<string> | null,
      depositId?: PromiseOrValue<BigNumberish> | null,
      amount?: null
    ): InitiateWithdrawEventFilter;
    InitiateWithdraw(
      owner?: PromiseOrValue<string> | null,
      depositId?: PromiseOrValue<BigNumberish> | null,
      amount?: null
    ): InitiateWithdrawEventFilter;

    "InterfaceAdded(bytes4)"(
      interfaceId?: PromiseOrValue<BytesLike> | null
    ): InterfaceAddedEventFilter;
    InterfaceAdded(
      interfaceId?: PromiseOrValue<BytesLike> | null
    ): InterfaceAddedEventFilter;

    "InterfaceRemoved(bytes4)"(
      interfaceId?: PromiseOrValue<BytesLike> | null
    ): InterfaceRemovedEventFilter;
    InterfaceRemoved(
      interfaceId?: PromiseOrValue<BytesLike> | null
    ): InterfaceRemovedEventFilter;

    "NotifyRewardAmount(address,uint256)"(
      notifier?: PromiseOrValue<string> | null,
      reward?: null
    ): NotifyRewardAmountEventFilter;
    NotifyRewardAmount(
      notifier?: PromiseOrValue<string> | null,
      reward?: null
    ): NotifyRewardAmountEventFilter;

    "OwnershipTransferred(address,address)"(
      previousOwner?: PromiseOrValue<string> | null,
      newOwner?: PromiseOrValue<string> | null
    ): OwnershipTransferredEventFilter;
    OwnershipTransferred(
      previousOwner?: PromiseOrValue<string> | null,
      newOwner?: PromiseOrValue<string> | null
    ): OwnershipTransferredEventFilter;

    "PeriodRewardAmountSet(uint256)"(
      amount?: null
    ): PeriodRewardAmountSetEventFilter;
    PeriodRewardAmountSet(amount?: null): PeriodRewardAmountSetEventFilter;

    "ProxyDelegationSet(address)"(
      proxyDelegation?: null
    ): ProxyDelegationSetEventFilter;
    ProxyDelegationSet(proxyDelegation?: null): ProxyDelegationSetEventFilter;

    "Redelegate(uint256,address)"(
      depositId?: PromiseOrValue<BigNumberish> | null,
      delegatee?: PromiseOrValue<string> | null
    ): RedelegateEventFilter;
    Redelegate(
      depositId?: PromiseOrValue<BigNumberish> | null,
      delegatee?: PromiseOrValue<string> | null
    ): RedelegateEventFilter;

    "RewardNotifierSet(address,bool)"(
      notifier?: PromiseOrValue<string> | null,
      enabled?: null
    ): RewardNotifierSetEventFilter;
    RewardNotifierSet(
      notifier?: PromiseOrValue<string> | null,
      enabled?: null
    ): RewardNotifierSetEventFilter;

    "RewardsDistributionInitialized(address,address,uint256)"(
      stakeToken?: null,
      rewardToken?: null,
      rewardDuration?: null
    ): RewardsDistributionInitializedEventFilter;
    RewardsDistributionInitialized(
      stakeToken?: null,
      rewardToken?: null,
      rewardDuration?: null
    ): RewardsDistributionInitializedEventFilter;

    "SpaceRewardsSwept(address,address,uint256)"(
      space?: PromiseOrValue<string> | null,
      operator?: PromiseOrValue<string> | null,
      scaledReward?: null
    ): SpaceRewardsSweptEventFilter;
    SpaceRewardsSwept(
      space?: PromiseOrValue<string> | null,
      operator?: PromiseOrValue<string> | null,
      scaledReward?: null
    ): SpaceRewardsSweptEventFilter;

    "Stake(address,address,address,uint256,uint96)"(
      owner?: PromiseOrValue<string> | null,
      delegatee?: PromiseOrValue<string> | null,
      beneficiary?: PromiseOrValue<string> | null,
      depositId?: null,
      amount?: null
    ): StakeEventFilter;
    Stake(
      owner?: PromiseOrValue<string> | null,
      delegatee?: PromiseOrValue<string> | null,
      beneficiary?: PromiseOrValue<string> | null,
      depositId?: null,
      amount?: null
    ): StakeEventFilter;

    "Upgraded(address)"(
      implementation?: PromiseOrValue<string> | null
    ): UpgradedEventFilter;
    Upgraded(
      implementation?: PromiseOrValue<string> | null
    ): UpgradedEventFilter;

    "Withdraw(uint256,uint96)"(
      depositId?: PromiseOrValue<BigNumberish> | null,
      amount?: null
    ): WithdrawEventFilter;
    Withdraw(
      depositId?: PromiseOrValue<BigNumberish> | null,
      amount?: null
    ): WithdrawEventFilter;
  };

  estimateGas: {
    __RewardsDistribution_init(
      stakeToken: PromiseOrValue<string>,
      rewardToken: PromiseOrValue<string>,
      rewardDuration: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    changeBeneficiary(
      depositId: PromiseOrValue<BigNumberish>,
      newBeneficiary: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    claimReward(
      beneficiary: PromiseOrValue<string>,
      recipient: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    currentReward(
      beneficiary: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    currentSpaceDelegationReward(
      operator: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    delegationProxyById(
      depositId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    depositById(
      depositId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getDepositsByDepositor(
      depositor: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    increaseStake(
      depositId: PromiseOrValue<BigNumberish>,
      amount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    initiateWithdraw(
      depositId: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    isRewardNotifier(
      notifier: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    notifyRewardAmount(
      reward: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    permitAndIncreaseStake(
      depositId: PromiseOrValue<BigNumberish>,
      amount: PromiseOrValue<BigNumberish>,
      nonce: PromiseOrValue<BigNumberish>,
      deadline: PromiseOrValue<BigNumberish>,
      signature: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    permitAndStake(
      amount: PromiseOrValue<BigNumberish>,
      delegatee: PromiseOrValue<string>,
      beneficiary: PromiseOrValue<string>,
      nonce: PromiseOrValue<BigNumberish>,
      deadline: PromiseOrValue<BigNumberish>,
      signature: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    redelegate(
      depositId: PromiseOrValue<BigNumberish>,
      delegatee: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setPeriodRewardAmount(
      amount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setRewardNotifier(
      notifier: PromiseOrValue<string>,
      enabled: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    stake(
      amount: PromiseOrValue<BigNumberish>,
      delegatee: PromiseOrValue<string>,
      beneficiary: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    stakeOnBehalf(
      amount: PromiseOrValue<BigNumberish>,
      delegatee: PromiseOrValue<string>,
      beneficiary: PromiseOrValue<string>,
      owner: PromiseOrValue<string>,
      arg4: PromiseOrValue<BigNumberish>,
      arg5: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    stakedByDepositor(
      depositor: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    treasureByBeneficiary(
      beneficiary: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    upgradeDelegationProxy(
      newImplementation: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    withdraw(
      depositId: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;
  };

  populateTransaction: {
    __RewardsDistribution_init(
      stakeToken: PromiseOrValue<string>,
      rewardToken: PromiseOrValue<string>,
      rewardDuration: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    changeBeneficiary(
      depositId: PromiseOrValue<BigNumberish>,
      newBeneficiary: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    claimReward(
      beneficiary: PromiseOrValue<string>,
      recipient: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    currentReward(
      beneficiary: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    currentSpaceDelegationReward(
      operator: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    delegationProxyById(
      depositId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    depositById(
      depositId: PromiseOrValue<BigNumberish>,