/* 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 interface IHorizonStakingMainInterface extends utils.Interface {
  functions: {
    "acceptProvisionParameters(address)": FunctionFragment;
    "addToDelegationPool(address,address,uint256)": FunctionFragment;
    "addToProvision(address,address,uint256)": FunctionFragment;
    "clearThawingPeriod()": FunctionFragment;
    "delegate(address,uint256)": FunctionFragment;
    "delegate(address,address,uint256,uint256)": FunctionFragment;
    "deprovision(address,address,uint256)": FunctionFragment;
    "getStakingExtension()": FunctionFragment;
    "isAuthorized(address,address,address)": FunctionFragment;
    "provision(address,address,uint256,uint32,uint64)": FunctionFragment;
    "provisionLocked(address,address,uint256,uint32,uint64)": FunctionFragment;
    "redelegate(address,address,address,address,uint256,uint256)": FunctionFragment;
    "reprovision(address,address,address,uint256)": FunctionFragment;
    "setAllowedLockedVerifier(address,bool)": FunctionFragment;
    "setDelegationFeeCut(address,address,uint8,uint256)": FunctionFragment;
    "setDelegationSlashingEnabled()": FunctionFragment;
    "setMaxThawingPeriod(uint64)": FunctionFragment;
    "setOperator(address,address,bool)": FunctionFragment;
    "setOperatorLocked(address,address,bool)": FunctionFragment;
    "setProvisionParameters(address,address,uint32,uint64)": FunctionFragment;
    "slash(address,uint256,uint256,address)": FunctionFragment;
    "stake(uint256)": FunctionFragment;
    "stakeTo(address,uint256)": FunctionFragment;
    "stakeToProvision(address,address,uint256)": FunctionFragment;
    "thaw(address,address,uint256)": FunctionFragment;
    "undelegate(address,uint256)": FunctionFragment;
    "undelegate(address,address,uint256)": FunctionFragment;
    "unstake(uint256)": FunctionFragment;
    "withdraw()": FunctionFragment;
    "withdrawDelegated(address,address,uint256)": FunctionFragment;
    "withdrawDelegated(address,address)": FunctionFragment;
  };

  getFunction(
    nameOrSignatureOrTopic:
      | "acceptProvisionParameters"
      | "addToDelegationPool"
      | "addToProvision"
      | "clearThawingPeriod"
      | "delegate(address,uint256)"
      | "delegate(address,address,uint256,uint256)"
      | "deprovision"
      | "getStakingExtension"
      | "isAuthorized"
      | "provision"
      | "provisionLocked"
      | "redelegate"
      | "reprovision"
      | "setAllowedLockedVerifier"
      | "setDelegationFeeCut"
      | "setDelegationSlashingEnabled"
      | "setMaxThawingPeriod"
      | "setOperator"
      | "setOperatorLocked"
      | "setProvisionParameters"
      | "slash"
      | "stake"
      | "stakeTo"
      | "stakeToProvision"
      | "thaw"
      | "undelegate(address,uint256)"
      | "undelegate(address,address,uint256)"
      | "unstake"
      | "withdraw"
      | "withdrawDelegated(address,address,uint256)"
      | "withdrawDelegated(address,address)",
  ): FunctionFragment;

  encodeFunctionData(
    functionFragment: "acceptProvisionParameters",
    values: [PromiseOrValue<string>],
  ): string;
  encodeFunctionData(
    functionFragment: "addToDelegationPool",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
    ],
  ): string;
  encodeFunctionData(
    functionFragment: "addToProvision",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
    ],
  ): string;
  encodeFunctionData(
    functionFragment: "clearThawingPeriod",
    values?: undefined,
  ): string;
  encodeFunctionData(
    functionFragment: "delegate(address,uint256)",
    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>],
  ): string;
  encodeFunctionData(
    functionFragment: "delegate(address,address,uint256,uint256)",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
    ],
  ): string;
  encodeFunctionData(
    functionFragment: "deprovision",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
    ],
  ): string;
  encodeFunctionData(
    functionFragment: "getStakingExtension",
    values?: undefined,
  ): string;
  encodeFunctionData(
    functionFragment: "isAuthorized",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<string>,
    ],
  ): string;
  encodeFunctionData(
    functionFragment: "provision",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
    ],
  ): string;
  encodeFunctionData(
    functionFragment: "provisionLocked",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
    ],
  ): string;
  encodeFunctionData(
    functionFragment: "redelegate",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
    ],
  ): string;
  encodeFunctionData(
    functionFragment: "reprovision",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
    ],
  ): string;
  encodeFunctionData(
    functionFragment: "setAllowedLockedVerifier",
    values: [PromiseOrValue<string>, PromiseOrValue<boolean>],
  ): string;
  encodeFunctionData(
    functionFragment: "setDelegationFeeCut",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
    ],
  ): string;
  encodeFunctionData(
    functionFragment: "setDelegationSlashingEnabled",
    values?: undefined,
  ): string;
  encodeFunctionData(
    functionFragment: "setMaxThawingPeriod",
    values: [PromiseOrValue<BigNumberish>],
  ): string;
  encodeFunctionData(
    functionFragment: "setOperator",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<boolean>,
    ],
  ): string;
  encodeFunctionData(
    functionFragment: "setOperatorLocked",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<boolean>,
    ],
  ): string;
  encodeFunctionData(
    functionFragment: "setProvisionParameters",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
    ],
  ): string;
  encodeFunctionData(
    functionFragment: "slash",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<string>,
    ],
  ): string;
  encodeFunctionData(
    functionFragment: "stake",
    values: [PromiseOrValue<BigNumberish>],
  ): string;
  encodeFunctionData(
    functionFragment: "stakeTo",
    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>],
  ): string;
  encodeFunctionData(
    functionFragment: "stakeToProvision",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
    ],
  ): string;
  encodeFunctionData(
    functionFragment: "thaw",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
    ],
  ): string;
  encodeFunctionData(
    functionFragment: "undelegate(address,uint256)",
    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>],
  ): string;
  encodeFunctionData(
    functionFragment: "undelegate(address,address,uint256)",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
    ],
  ): string;
  encodeFunctionData(
    functionFragment: "unstake",
    values: [PromiseOrValue<BigNumberish>],
  ): string;
  encodeFunctionData(functionFragment: "withdraw", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "withdrawDelegated(address,address,uint256)",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
    ],
  ): string;
  encodeFunctionData(
    functionFragment: "withdrawDelegated(address,address)",
    values: [PromiseOrValue<string>, PromiseOrValue<string>],
  ): string;

  decodeFunctionResult(
    functionFragment: "acceptProvisionParameters",
    data: BytesLike,
  ): Result;
  decodeFunctionResult(
    functionFragment: "addToDelegationPool",
    data: BytesLike,
  ): Result;
  decodeFunctionResult(
    functionFragment: "addToProvision",
    data: BytesLike,
  ): Result;
  decodeFunctionResult(
    functionFragment: "clearThawingPeriod",
    data: BytesLike,
  ): Result;
  decodeFunctionResult(
    functionFragment: "delegate(address,uint256)",
    data: BytesLike,
  ): Result;
  decodeFunctionResult(
    functionFragment: "delegate(address,address,uint256,uint256)",
    data: BytesLike,
  ): Result;
  decodeFunctionResult(
    functionFragment: "deprovision",
    data: BytesLike,
  ): Result;
  decodeFunctionResult(
    functionFragment: "getStakingExtension",
    data: BytesLike,
  ): Result;
  decodeFunctionResult(
    functionFragment: "isAuthorized",
    data: BytesLike,
  ): Result;
  decodeFunctionResult(functionFragment: "provision", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "provisionLocked",
    data: BytesLike,
  ): Result;
  decodeFunctionResult(functionFragment: "redelegate", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "reprovision",
    data: BytesLike,
  ): Result;
  decodeFunctionResult(
    functionFragment: "setAllowedLockedVerifier",
    data: BytesLike,
  ): Result;
  decodeFunctionResult(
    functionFragment: "setDelegationFeeCut",
    data: BytesLike,
  ): Result;
  decodeFunctionResult(
    functionFragment: "setDelegationSlashingEnabled",
    data: BytesLike,
  ): Result;
  decodeFunctionResult(
    functionFragment: "setMaxThawingPeriod",
    data: BytesLike,
  ): Result;
  decodeFunctionResult(
    functionFragment: "setOperator",
    data: BytesLike,
  ): Result;
  decodeFunctionResult(
    functionFragment: "setOperatorLocked",
    data: BytesLike,
  ): Result;
  decodeFunctionResult(
    functionFragment: "setProvisionParameters",
    data: BytesLike,
  ): Result;
  decodeFunctionResult(functionFragment: "slash", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "stake", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "stakeTo", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "stakeToProvision",
    data: BytesLike,
  ): Result;
  decodeFunctionResult(functionFragment: "thaw", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "undelegate(address,uint256)",
    data: BytesLike,
  ): Result;
  decodeFunctionResult(
    functionFragment: "undelegate(address,address,uint256)",
    data: BytesLike,
  ): Result;
  decodeFunctionResult(functionFragment: "unstake", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "withdrawDelegated(address,address,uint256)",
    data: BytesLike,
  ): Result;
  decodeFunctionResult(
    functionFragment: "withdrawDelegated(address,address)",
    data: BytesLike,
  ): Result;

  events: {
    "AllowedLockedVerifierSet(address,bool)": EventFragment;
    "DelegatedTokensWithdrawn(address,address,address,uint256)": EventFragment;
    "DelegationFeeCutSet(address,address,uint8,uint256)": EventFragment;
    "DelegationSlashed(address,address,uint256)": EventFragment;
    "DelegationSlashingEnabled()": EventFragment;
    "DelegationSlashingSkipped(address,address,uint256)": EventFragment;
    "HorizonStakeLocked(address,uint256,uint256)": EventFragment;
    "HorizonStakeWithdrawn(address,uint256)": EventFragment;
    "MaxThawingPeriodSet(uint64)": EventFragment;
    "OperatorSet(address,address,address,bool)": EventFragment;
    "ProvisionCreated(address,address,uint256,uint32,uint64)": EventFragment;
    "ProvisionIncreased(address,address,uint256)": EventFragment;
    "ProvisionParametersSet(address,address,uint32,uint64)": EventFragment;
    "ProvisionParametersStaged(address,address,uint32,uint64)": EventFragment;
    "ProvisionSlashed(address,address,uint256)": EventFragment;
    "ProvisionThawed(address,address,uint256)": EventFragment;
    "StakeDelegatedWithdrawn(address,address,uint256)": EventFragment;
    "ThawRequestCreated(uint8,address,address,address,uint256,uint64,bytes32,uint256)": EventFragment;
    "ThawRequestFulfilled(uint8,bytes32,uint256,uint256,uint64,bool)": EventFragment;
    "ThawRequestsFulfilled(uint8,address,address,address,uint256,uint256)": EventFragment;
    "ThawingPeriodCleared()": EventFragment;
    "TokensDelegated(address,address,address,uint256,uint256)": EventFragment;
    "TokensDeprovisioned(address,address,uint256)": EventFragment;
    "TokensToDelegationPoolAdded(address,address,uint256)": EventFragment;
    "TokensUndelegated(address,address,address,uint256,uint256)": EventFragment;
    "VerifierTokensSent(address,address,address,uint256)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "AllowedLockedVerifierSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "DelegatedTokensWithdrawn"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "DelegationFeeCutSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "DelegationSlashed"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "DelegationSlashingEnabled"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "DelegationSlashingSkipped"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "HorizonStakeLocked"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "HorizonStakeWithdrawn"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "MaxThawingPeriodSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "OperatorSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ProvisionCreated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ProvisionIncreased"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ProvisionParametersSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ProvisionParametersStaged"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ProvisionSlashed"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ProvisionThawed"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "StakeDelegatedWithdrawn"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ThawRequestCreated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ThawRequestFulfilled"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ThawRequestsFulfilled"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ThawingPeriodCleared"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "TokensDelegated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "TokensDeprovisioned"): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "TokensToDelegationPoolAdded",
  ): EventFragment;
  getEvent(nameOrSignatureOrTopic: "TokensUndelegated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "VerifierTokensSent"): EventFragment;
}

export interface AllowedLockedVerifierSetEventObject {
  verifier: string;
  allowed: boolean;
}
export type AllowedLockedVerifierSetEvent = TypedEvent<
  [string, boolean],
  AllowedLockedVerifierSetEventObject
>;

export type AllowedLockedVerifierSetEventFilter =
  TypedEventFilter<AllowedLockedVerifierSetEvent>;

export interface DelegatedTokensWithdrawnEventObject {
  serviceProvider: string;
  verifier: string;
  delegator: string;
  tokens: BigNumber;
}
export type DelegatedTokensWithdrawnEvent = TypedEvent<
  [string, string, string, BigNumber],
  DelegatedTokensWithdrawnEventObject
>;

export type DelegatedTokensWithdrawnEventFilter =
  TypedEventFilter<DelegatedTokensWithdrawnEvent>;

export interface DelegationFeeCutSetEventObject {
  serviceProvider: string;
  verifier: string;
  paymentType: number;
  feeCut: BigNumber;
}
export type DelegationFeeCutSetEvent = TypedEvent<
  [string, string, number, BigNumber],
  DelegationFeeCutSetEventObject
>;

export type DelegationFeeCutSetEventFilter =
  TypedEventFilter<DelegationFeeCutSetEvent>;

export interface DelegationSlashedEventObject {
  serviceProvider: string;
  verifier: string;
  tokens: BigNumber;
}
export type DelegationSlashedEvent = TypedEvent<
  [string, string, BigNumber],
  DelegationSlashedEventObject
>;

export type DelegationSlashedEventFilter =
  TypedEventFilter<DelegationSlashedEvent>;

export interface DelegationSlashingEnabledEventObject {}
export type DelegationSlashingEnabledEvent = TypedEvent<
  [],
  DelegationSlashingEnabledEventObject
>;

export type DelegationSlashingEnabledEventFilter =
  TypedEventFilter<DelegationSlashingEnabledEvent>;

export interface DelegationSlashingSkippedEventObject {
  serviceProvider: string;
  verifier: string;
  tokens: BigNumber;
}
export type DelegationSlashingSkippedEvent = TypedEvent<
  [string, string, BigNumber],
  DelegationSlashingSkippedEventObject
>;

export type DelegationSlashingSkippedEventFilter =
  TypedEventFilter<DelegationSlashingSkippedEvent>;

export interface HorizonStakeLockedEventObject {
  serviceProvider: string;
  tokens: BigNumber;
  until: BigNumber;
}
export type HorizonStakeLockedEvent = TypedEvent<
  [string, BigNumber, BigNumber],
  HorizonStakeLockedEventObject
>;

export type HorizonStakeLockedEventFilter =
  TypedEventFilter<HorizonStakeLockedEvent>;

export interface HorizonStakeWithdrawnEventObject {
  serviceProvider: string;
  tokens: BigNumber;
}
export type HorizonStakeWithdrawnEvent = TypedEvent<
  [string, BigNumber],
  HorizonStakeWithdrawnEventObject
>;

export type HorizonStakeWithdrawnEventFilter =
  TypedEventFilter<HorizonStakeWithdrawnEvent>;

export interface MaxThawingPeriodSetEventObject {
  maxThawingPeriod: BigNumber;
}
export type MaxThawingPeriodSetEvent = TypedEvent<
  [BigNumber],
  MaxThawingPeriodSetEventObject
>;

export type MaxThawingPeriodSetEventFilter =
  TypedEventFilter<MaxThawingPeriodSetEvent>;

export interface OperatorSetEventObject {
  serviceProvider: string;
  verifier: string;
  operator: string;
  allowed: boolean;
}
export type OperatorSetEvent = TypedEvent<
  [string, string, string, boolean],
  OperatorSetEventObject
>;

export type OperatorSetEventFilter = TypedEventFilter<OperatorSetEvent>;

export interface ProvisionCreatedEventObject {
  serviceProvider: string;
  verifier: string;
  tokens: BigNumber;
  maxVerifierCut: number;
  thawingPeriod: BigNumber;
}
export type ProvisionCreatedEvent = TypedEvent<
  [string, string, BigNumber, number, BigNumber],
  ProvisionCreatedEventObject
>;

export type ProvisionCreatedEventFilter =
  TypedEventFilter<ProvisionCreatedEvent>;

export interface ProvisionIncreasedEventObject {
  serviceProvider: string;
  verifier: string;
  tokens: BigNumber;
}
export type ProvisionIncreasedEvent = TypedEvent<
  [string, string, BigNumber],
  ProvisionIncreasedEventObject
>;

export type ProvisionIncreasedEventFilter =
  TypedEventFilter<ProvisionIncreasedEvent>;

export interface ProvisionParametersSetEventObject {
  serviceProvider: string;
  verifier: string;
  maxVerifierCut: number;
  thawingPeriod: BigNumber;
}
export type ProvisionParametersSetEvent = TypedEvent<
  [string, string, number, BigNumber],
  ProvisionParametersSetEventObject
>;

export type ProvisionParametersSetEventFilter =
  TypedEventFilter<ProvisionParametersSetEvent>;

export interface ProvisionParametersStagedEventObject {
  serviceProvider: string;
  verifier: string;
  maxVerifierCut: number;
  thawingPeriod: BigNumber;
}
export type ProvisionParametersStagedEvent = TypedEvent<
  [string, string, number, BigNumber],
  ProvisionParametersStagedEventObject
>;

export type ProvisionParametersStagedEventFilter =
  TypedEventFilter<ProvisionParametersStagedEvent>;

export interface ProvisionSlashedEventObject {
  serviceProvider: string;
  verifier: string;
  tokens: BigNumber;
}
export type ProvisionSlashedEvent = TypedEvent<
  [string, string, BigNumber],
  ProvisionSlashedEventObject
>;

export type ProvisionSlashedEventFilter =
  TypedEventFilter<ProvisionSlashedEvent>;

export interface ProvisionThawedEventObject {
  serviceProvider: string;
  verifier: string;
  tokens: BigNumber;
}
export type ProvisionThawedEvent = TypedEvent<
  [string, string, BigNumber],
  ProvisionThawedEventObject
>;

export type ProvisionThawedEventFilter = TypedEventFilter<ProvisionThawedEvent>;

export interface StakeDelegatedWithdrawnEventObject {
  indexer: string;
  delegator: string;
  tokens: BigNumber;
}
export type StakeDelegatedWithdrawnEvent = TypedEvent<
  [string, string, BigNumber],
  StakeDelegatedWithdrawnEventObject
>;

export type StakeDelegatedWithdrawnEventFilter =
  TypedEventFilter<StakeDelegatedWithdrawnEvent>;

export interface ThawRequestCreatedEventObject {
  requestType: number;
  serviceProvider: string;
  verifier: string;
  owner: string;
  shares: BigNumber;
  thawingUntil: BigNumber;
  thawRequestId: string;
  nonce: BigNumber;
}
export type ThawRequestCreatedEvent = TypedEvent<
  [number, string, string, string, BigNumber, BigNumber, string, BigNumber],
  ThawRequestCreatedEventObject
>;

export type ThawRequestCreatedEventFilter =
  TypedEventFilter<ThawRequestCreatedEvent>;

export interface ThawRequestFulfilledEventObject {
  requestType: number;
  thawRequestId: string;
  tokens: BigNumber;
  shares: BigNumber;
  thawingUntil: BigNumber;
  valid: boolean;
}
export type ThawRequestFulfilledEvent = TypedEvent<
  [number, string, BigNumber, BigNumber, BigNumber, boolean],
  ThawRequestFulfilledEventObject
>;

export type ThawRequestFulfilledEventFilter =
  TypedEventFilter<ThawRequestFulfilledEvent>;

export interface ThawRequestsFulfilledEventObject {
  requestType: number;
  serviceProvider: string;
  verifier: string;
  owner: string;
  thawRequestsFulfilled: BigNumber;
  tokens: BigNumber;
}
export type ThawRequestsFulfilledEvent = TypedEvent<
  [number, string, string, string, BigNumber, BigNumber],
  ThawRequestsFulfilledEventObject
>;

export type ThawRequestsFulfilledEventFilter =
  TypedEventFilter<ThawRequestsFulfilledEvent>;

export interface ThawingPeriodClearedEventObject {}
export type ThawingPeriodClearedEvent = TypedEvent<
  [],
  ThawingPeriodClearedEventObject
>;

export type ThawingPeriodClearedEventFilter =
  TypedEventFilter<ThawingPeriodClearedEvent>;

export interface TokensDelegatedEventObject {
  serviceProvider: string;
  verifier: string;
  delegator: string;
  tokens: BigNumber;
  shares: BigNumber;
}
export type TokensDelegatedEvent = TypedEvent<
  [string, string, string, BigNumber, BigNumber],
  TokensDelegatedEventObject
>;

export type TokensDelegatedEventFilter = TypedEventFilter<TokensDelegatedEvent>;

export interface TokensDeprovisionedEventObject {
  serviceProvider: string;
  verifier: string;
  tokens: BigNumber;
}
export type TokensDeprovisionedEvent = TypedEvent<
  [string, string, BigNumber],
  TokensDeprovisionedEventObject
>;

export type TokensDeprovisionedEventFilter =
  TypedEventFilter<TokensDeprovisionedEvent>;

export interface TokensToDelegationPoolAddedEventObject {
  serviceProvider: string;
  verifier: string;
  tokens: BigNumber;
}
export type TokensToDelegationPoolAddedEvent = TypedEvent<
  [string, string, BigNumber],
  TokensToDelegationPoolAddedEventObject
>;

export type TokensToDelegationPoolAddedEventFilter =
  TypedEventFilter<TokensToDelegationPoolAddedEvent>;

export interface TokensUndelegatedEventObject {
  serviceProvider: string;
  verifier: string;
  delegator: string;
  tokens: BigNumber;
  shares: BigNumber;
}
export type TokensUndelegatedEvent = TypedEvent<
  [string, string, string, BigNumber, BigNumber],
  TokensUndelegatedEventObject
>;

export type TokensUndelegatedEventFilter =
  TypedEventFilter<TokensUndelegatedEvent>;

export interface VerifierTokensSentEventObject {
  serviceProvider: string;
  verifier: string;
  destination: string;
  tokens: BigNumber;
}
export type VerifierTokensSentEvent = TypedEvent<
  [string, string, string, BigNumber],
  VerifierTokensSentEventObject
>;

export type VerifierTokensSentEventFilter =
  TypedEventFilter<VerifierTokensSentEvent>;

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

  interface: IHorizonStakingMainInterface;

  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: {
    acceptProvisionParameters(
      serviceProvider: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<ContractTransaction>;

    addToDelegationPool(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      tokens: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<ContractTransaction>;

    addToProvision(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      tokens: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<ContractTransaction>;

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

    "delegate(address,uint256)"(
      serviceProvider: PromiseOrValue<string>,
      tokens: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<ContractTransaction>;

    "delegate(address,address,uint256,uint256)"(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      tokens: PromiseOrValue<BigNumberish>,
      minSharesOut: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<ContractTransaction>;

    deprovision(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      nThawRequests: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<ContractTransaction>;

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

    isAuthorized(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      operator: PromiseOrValue<string>,
      overrides?: CallOverrides,
    ): Promise<[boolean]>;

    provision(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      tokens: PromiseOrValue<BigNumberish>,
      maxVerifierCut: PromiseOrValue<BigNumberish>,
      thawingPeriod: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<ContractTransaction>;

    provisionLocked(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      tokens: PromiseOrValue<BigNumberish>,
      maxVerifierCut: PromiseOrValue<BigNumberish>,
      thawingPeriod: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<ContractTransaction>;

    redelegate(
      oldServiceProvider: PromiseOrValue<string>,
      oldVerifier: PromiseOrValue<string>,
      newServiceProvider: PromiseOrValue<string>,
      newVerifier: PromiseOrValue<string>,
      minSharesForNewProvider: PromiseOrValue<BigNumberish>,
      nThawRequests: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<ContractTransaction>;

    reprovision(
      serviceProvider: PromiseOrValue<string>,
      oldVerifier: PromiseOrValue<string>,
      newVerifier: PromiseOrValue<string>,
      nThawRequests: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<ContractTransaction>;

    setAllowedLockedVerifier(
      verifier: PromiseOrValue<string>,
      allowed: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<ContractTransaction>;

    setDelegationFeeCut(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      paymentType: PromiseOrValue<BigNumberish>,
      feeCut: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<ContractTransaction>;

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

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

    setOperator(
      verifier: PromiseOrValue<string>,
      operator: PromiseOrValue<string>,
      allowed: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<ContractTransaction>;

    setOperatorLocked(
      verifier: PromiseOrValue<string>,
      operator: PromiseOrValue<string>,
      allowed: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<ContractTransaction>;

    setProvisionParameters(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      maxVerifierCut: PromiseOrValue<BigNumberish>,
      thawingPeriod: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<ContractTransaction>;

    slash(
      serviceProvider: PromiseOrValue<string>,
      tokens: PromiseOrValue<BigNumberish>,
      tokensVerifier: PromiseOrValue<BigNumberish>,
      verifierDestination: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<ContractTransaction>;

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

    stakeTo(
      serviceProvider: PromiseOrValue<string>,
      tokens: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<ContractTransaction>;

    stakeToProvision(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      tokens: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<ContractTransaction>;

    thaw(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      tokens: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<ContractTransaction>;

    "undelegate(address,uint256)"(
      serviceProvider: PromiseOrValue<string>,
      shares: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<ContractTransaction>;

    "undelegate(address,address,uint256)"(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      shares: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<ContractTransaction>;

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

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

    "withdrawDelegated(address,address,uint256)"(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      nThawRequests: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<ContractTransaction>;

    "withdrawDelegated(address,address)"(
      serviceProvider: PromiseOrValue<string>,
      deprecated: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<ContractTransaction>;
  };

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

  addToDelegationPool(
    serviceProvider: PromiseOrValue<string>,
    verifier: PromiseOrValue<string>,
    tokens: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> },
  ): Promise<ContractTransaction>;

  addToProvision(
    serviceProvider: PromiseOrValue<string>,
    verifier: PromiseOrValue<string>,
    tokens: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> },
  ): Promise<ContractTransaction>;

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

  "delegate(address,uint256)"(
    serviceProvider: PromiseOrValue<string>,
    tokens: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> },
  ): Promise<ContractTransaction>;

  "delegate(address,address,uint256,uint256)"(
    serviceProvider: PromiseOrValue<string>,
    verifier: PromiseOrValue<string>,
    tokens: PromiseOrValue<BigNumberish>,
    minSharesOut: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> },
  ): Promise<ContractTransaction>;

  deprovision(
    serviceProvider: PromiseOrValue<string>,
    verifier: PromiseOrValue<string>,
    nThawRequests: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> },
  ): Promise<ContractTransaction>;

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

  isAuthorized(
    serviceProvider: PromiseOrValue<string>,
    verifier: PromiseOrValue<string>,
    operator: PromiseOrValue<string>,
    overrides?: CallOverrides,
  ): Promise<boolean>;

  provision(
    serviceProvider: PromiseOrValue<string>,
    verifier: PromiseOrValue<string>,
    tokens: PromiseOrValue<BigNumberish>,
    maxVerifierCut: PromiseOrValue<BigNumberish>,
    thawingPeriod: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> },
  ): Promise<ContractTransaction>;

  provisionLocked(
    serviceProvider: PromiseOrValue<string>,
    verifier: PromiseOrValue<string>,
    tokens: PromiseOrValue<BigNumberish>,
    maxVerifierCut: PromiseOrValue<BigNumberish>,
    thawingPeriod: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> },
  ): Promise<ContractTransaction>;

  redelegate(
    oldServiceProvider: PromiseOrValue<string>,
    oldVerifier: PromiseOrValue<string>,
    newServiceProvider: PromiseOrValue<string>,
    newVerifier: PromiseOrValue<string>,
    minSharesForNewProvider: PromiseOrValue<BigNumberish>,
    nThawRequests: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> },
  ): Promise<ContractTransaction>;

  reprovision(
    serviceProvider: PromiseOrValue<string>,
    oldVerifier: PromiseOrValue<string>,
    newVerifier: PromiseOrValue<string>,
    nThawRequests: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> },
  ): Promise<ContractTransaction>;

  setAllowedLockedVerifier(
    verifier: PromiseOrValue<string>,
    allowed: PromiseOrValue<boolean>,
    overrides?: Overrides & { from?: PromiseOrValue<string> },
  ): Promise<ContractTransaction>;

  setDelegationFeeCut(
    serviceProvider: PromiseOrValue<string>,
    verifier: PromiseOrValue<string>,
    paymentType: PromiseOrValue<BigNumberish>,
    feeCut: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> },
  ): Promise<ContractTransaction>;

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

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

  setOperator(
    verifier: PromiseOrValue<string>,
    operator: PromiseOrValue<string>,
    allowed: PromiseOrValue<boolean>,
    overrides?: Overrides & { from?: PromiseOrValue<string> },
  ): Promise<ContractTransaction>;

  setOperatorLocked(
    verifier: PromiseOrValue<string>,
    operator: PromiseOrValue<string>,
    allowed: PromiseOrValue<boolean>,
    overrides?: Overrides & { from?: PromiseOrValue<string> },
  ): Promise<ContractTransaction>;

  setProvisionParameters(
    serviceProvider: PromiseOrValue<string>,
    verifier: PromiseOrValue<string>,
    maxVerifierCut: PromiseOrValue<BigNumberish>,
    thawingPeriod: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> },
  ): Promise<ContractTransaction>;

  slash(
    serviceProvider: PromiseOrValue<string>,
    tokens: PromiseOrValue<BigNumberish>,
    tokensVerifier: PromiseOrValue<BigNumberish>,
    verifierDestination: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> },
  ): Promise<ContractTransaction>;

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

  stakeTo(
    serviceProvider: PromiseOrValue<string>,
    tokens: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> },
  ): Promise<ContractTransaction>;

  stakeToProvision(
    serviceProvider: PromiseOrValue<string>,
    verifier: PromiseOrValue<string>,
    tokens: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> },
  ): Promise<ContractTransaction>;

  thaw(
    serviceProvider: PromiseOrValue<string>,
    verifier: PromiseOrValue<string>,
    tokens: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> },
  ): Promise<ContractTransaction>;

  "undelegate(address,uint256)"(
    serviceProvider: PromiseOrValue<string>,
    shares: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> },
  ): Promise<ContractTransaction>;

  "undelegate(address,address,uint256)"(
    serviceProvider: PromiseOrValue<string>,
    verifier: PromiseOrValue<string>,
    shares: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> },
  ): Promise<ContractTransaction>;

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

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

  "withdrawDelegated(address,address,uint256)"(
    serviceProvider: PromiseOrValue<string>,
    verifier: PromiseOrValue<string>,
    nThawRequests: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> },
  ): Promise<ContractTransaction>;

  "withdrawDelegated(address,address)"(
    serviceProvider: PromiseOrValue<string>,
    deprecated: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> },
  ): Promise<ContractTransaction>;

  callStatic: {
    acceptProvisionParameters(
      serviceProvider: PromiseOrValue<string>,
      overrides?: CallOverrides,
    ): Promise<void>;

    addToDelegationPool(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      tokens: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides,
    ): Promise<void>;

    addToProvision(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      tokens: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides,
    ): Promise<void>;

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

    "delegate(address,uint256)"(
      serviceProvider: PromiseOrValue<string>,
      tokens: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides,
    ): Promise<void>;

    "delegate(address,address,uint256,uint256)"(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      tokens: PromiseOrValue<BigNumberish>,
      minSharesOut: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides,
    ): Promise<void>;

    deprovision(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      nThawRequests: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides,
    ): Promise<void>;

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

    isAuthorized(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      operator: PromiseOrValue<string>,
      overrides?: CallOverrides,
    ): Promise<boolean>;

    provision(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      tokens: PromiseOrValue<BigNumberish>,
      maxVerifierCut: PromiseOrValue<BigNumberish>,
      thawingPeriod: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides,
    ): Promise<void>;

    provisionLocked(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      tokens: PromiseOrValue<BigNumberish>,
      maxVerifierCut: PromiseOrValue<BigNumberish>,
      thawingPeriod: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides,
    ): Promise<void>;

    redelegate(
      oldServiceProvider: PromiseOrValue<string>,
      oldVerifier: PromiseOrValue<string>,
      newServiceProvider: PromiseOrValue<string>,
      newVerifier: PromiseOrValue<string>,
      minSharesForNewProvider: PromiseOrValue<BigNumberish>,
      nThawRequests: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides,
    ): Promise<void>;

    reprovision(
      serviceProvider: PromiseOrValue<string>,
      oldVerifier: PromiseOrValue<string>,
      newVerifier: PromiseOrValue<string>,
      nThawRequests: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides,
    ): Promise<void>;

    setAllowedLockedVerifier(
      verifier: PromiseOrValue<string>,
      allowed: PromiseOrValue<boolean>,
      overrides?: CallOverrides,
    ): Promise<void>;

    setDelegationFeeCut(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      paymentType: PromiseOrValue<BigNumberish>,
      feeCut: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides,
    ): Promise<void>;

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

    setMaxThawingPeriod(
      maxThawingPeriod: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides,
    ): Promise<void>;

    setOperator(
      verifier: PromiseOrValue<string>,
      operator: PromiseOrValue<string>,
      allowed: PromiseOrValue<boolean>,
      overrides?: CallOverrides,
    ): Promise<void>;

    setOperatorLocked(
      verifier: PromiseOrValue<string>,
      operator: PromiseOrValue<string>,
      allowed: PromiseOrValue<boolean>,
      overrides?: CallOverrides,
    ): Promise<void>;

    setProvisionParameters(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      maxVerifierCut: PromiseOrValue<BigNumberish>,
      thawingPeriod: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides,
    ): Promise<void>;

    slash(
      serviceProvider: PromiseOrValue<string>,
      tokens: PromiseOrValue<BigNumberish>,
      tokensVerifier: PromiseOrValue<BigNumberish>,
      verifierDestination: PromiseOrValue<string>,
      overrides?: CallOverrides,
    ): Promise<void>;

    stake(
      tokens: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides,
    ): Promise<void>;

    stakeTo(
      serviceProvider: PromiseOrValue<string>,
      tokens: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides,
    ): Promise<void>;

    stakeToProvision(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      tokens: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides,
    ): Promise<void>;

    thaw(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      tokens: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides,
    ): Promise<string>;

    "undelegate(address,uint256)"(
      serviceProvider: PromiseOrValue<string>,
      shares: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides,
    ): Promise<void>;

    "undelegate(address,address,uint256)"(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      shares: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides,
    ): Promise<string>;

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

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

    "withdrawDelegated(address,address,uint256)"(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      nThawRequests: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides,
    ): Promise<void>;

    "withdrawDelegated(address,address)"(
      serviceProvider: PromiseOrValue<string>,
      deprecated: PromiseOrValue<string>,
      overrides?: CallOverrides,
    ): Promise<BigNumber>;
  };

  filters: {
    "AllowedLockedVerifierSet(address,bool)"(
      verifier?: PromiseOrValue<string> | null,
      allowed?: null,
    ): AllowedLockedVerifierSetEventFilter;
    AllowedLockedVerifierSet(
      verifier?: PromiseOrValue<string> | null,
      allowed?: null,
    ): AllowedLockedVerifierSetEventFilter;

    "DelegatedTokensWithdrawn(address,address,address,uint256)"(
      serviceProvider?: PromiseOrValue<string> | null,
      verifier?: PromiseOrValue<string> | null,
      delegator?: PromiseOrValue<string> | null,
      tokens?: null,
    ): DelegatedTokensWithdrawnEventFilter;
    DelegatedTokensWithdrawn(
      serviceProvider?: PromiseOrValue<string> | null,
      verifier?: PromiseOrValue<string> | null,
      delegator?: PromiseOrValue<string> | null,
      tokens?: null,
    ): DelegatedTokensWithdrawnEventFilter;

    "DelegationFeeCutSet(address,address,uint8,uint256)"(
      serviceProvider?: PromiseOrValue<string> | null,
      verifier?: PromiseOrValue<string> | null,
      paymentType?: PromiseOrValue<BigNumberish> | null,
      feeCut?: null,
    ): DelegationFeeCutSetEventFilter;
    DelegationFeeCutSet(
      serviceProvider?: PromiseOrValue<string> | null,
      verifier?: PromiseOrValue<string> | null,
      paymentType?: PromiseOrValue<BigNumberish> | null,
      feeCut?: null,
    ): DelegationFeeCutSetEventFilter;

    "DelegationSlashed(address,address,uint256)"(
      serviceProvider?: PromiseOrValue<string> | null,
      verifier?: PromiseOrValue<string> | null,
      tokens?: null,
    ): DelegationSlashedEventFilter;
    DelegationSlashed(
      serviceProvider?: PromiseOrValue<string> | null,
      verifier?: PromiseOrValue<string> | null,
      tokens?: null,
    ): DelegationSlashedEventFilter;

    "DelegationSlashingEnabled()"(): DelegationSlashingEnabledEventFilter;
    DelegationSlashingEnabled(): DelegationSlashingEnabledEventFilter;

    "DelegationSlashingSkipped(address,address,uint256)"(
      serviceProvider?: PromiseOrValue<string> | null,
      verifier?: PromiseOrValue<string> | null,
      tokens?: null,
    ): DelegationSlashingSkippedEventFilter;
    DelegationSlashingSkipped(
      serviceProvider?: PromiseOrValue<string> | null,
      verifier?: PromiseOrValue<string> | null,
      tokens?: null,
    ): DelegationSlashingSkippedEventFilter;

    "HorizonStakeLocked(address,uint256,uint256)"(
      serviceProvider?: PromiseOrValue<string> | null,
      tokens?: null,
      until?: null,
    ): HorizonStakeLockedEventFilter;
    HorizonStakeLocked(
      serviceProvider?: PromiseOrValue<string> | null,
      tokens?: null,
      until?: null,
    ): HorizonStakeLockedEventFilter;

    "HorizonStakeWithdrawn(address,uint256)"(
      serviceProvider?: PromiseOrValue<string> | null,
      tokens?: null,
    ): HorizonStakeWithdrawnEventFilter;
    HorizonStakeWithdrawn(
      serviceProvider?: PromiseOrValue<string> | null,
      tokens?: null,
    ): HorizonStakeWithdrawnEventFilter;

    "MaxThawingPeriodSet(uint64)"(
      maxThawingPeriod?: null,
    ): MaxThawingPeriodSetEventFilter;
    MaxThawingPeriodSet(
      maxThawingPeriod?: null,
    ): MaxThawingPeriodSetEventFilter;

    "OperatorSet(address,address,address,bool)"(
      serviceProvider?: PromiseOrValue<string> | null,
      verifier?: PromiseOrValue<string> | null,
      operator?: PromiseOrValue<string> | null,
      allowed?: null,
    ): OperatorSetEventFilter;
    OperatorSet(
      serviceProvider?: PromiseOrValue<string> | null,
      verifier?: PromiseOrValue<string> | null,
      operator?: PromiseOrValue<string> | null,
      allowed?: null,
    ): OperatorSetEventFilter;

    "ProvisionCreated(address,address,uint256,uint32,uint64)"(
      serviceProvider?: PromiseOrValue<string> | null,
      verifier?: PromiseOrValue<string> | null,
      tokens?: null,
      maxVerifierCut?: null,
      thawingPeriod?: null,
    ): ProvisionCreatedEventFilter;
    ProvisionCreated(
      serviceProvider?: PromiseOrValue<string> | null,
      verifier?: PromiseOrValue<string> | null,
      tokens?: null,
      maxVerifierCut?: null,
      thawingPeriod?: null,
    ): ProvisionCreatedEventFilter;

    "ProvisionIncreased(address,address,uint256)"(
      serviceProvider?: PromiseOrValue<string> | null,
      verifier?: PromiseOrValue<string> | null,
      tokens?: null,
    ): ProvisionIncreasedEventFilter;
    ProvisionIncreased(
      serviceProvider?: PromiseOrValue<string> | null,
      verifier?: PromiseOrValue<string> | null,
      tokens?: null,
    ): ProvisionIncreasedEventFilter;

    "ProvisionParametersSet(address,address,uint32,uint64)"(
      serviceProvider?: PromiseOrValue<string> | null,
      verifier?: PromiseOrValue<string> | null,
      maxVerifierCut?: null,
      thawingPeriod?: null,
    ): ProvisionParametersSetEventFilter;
    ProvisionParametersSet(
      serviceProvider?: PromiseOrValue<string> | null,
      verifier?: PromiseOrValue<string> | null,
      maxVerifierCut?: null,
      thawingPeriod?: null,
    ): ProvisionParametersSetEventFilter;

    "ProvisionParametersStaged(address,address,uint32,uint64)"(
      serviceProvider?: PromiseOrValue<string> | null,
      verifier?: PromiseOrValue<string> | null,
      maxVerifierCut?: null,
      thawingPeriod?: null,
    ): ProvisionParametersStagedEventFilter;
    ProvisionParametersStaged(
      serviceProvider?: PromiseOrValue<string> | null,
      verifier?: PromiseOrValue<string> | null,
      maxVerifierCut?: null,
      thawingPeriod?: null,
    ): ProvisionParametersStagedEventFilter;

    "ProvisionSlashed(address,address,uint256)"(
      serviceProvider?: PromiseOrValue<string> | null,
      verifier?: PromiseOrValue<string> | null,
      tokens?: null,
    ): ProvisionSlashedEventFilter;
    ProvisionSlashed(
      serviceProvider?: PromiseOrValue<string> | null,
      verifier?: PromiseOrValue<string> | null,
      tokens?: null,
    ): ProvisionSlashedEventFilter;

    "ProvisionThawed(address,address,uint256)"(
      serviceProvider?: PromiseOrValue<string> | null,
      verifier?: PromiseOrValue<string> | null,
      tokens?: null,
    ): ProvisionThawedEventFilter;
    ProvisionThawed(
      serviceProvider?: PromiseOrValue<string> | null,
      verifier?: PromiseOrValue<string> | null,
      tokens?: null,
    ): ProvisionThawedEventFilter;

    "StakeDelegatedWithdrawn(address,address,uint256)"(
      indexer?: PromiseOrValue<string> | null,
      delegator?: PromiseOrValue<string> | null,
      tokens?: null,
    ): StakeDelegatedWithdrawnEventFilter;
    StakeDelegatedWithdrawn(
      indexer?: PromiseOrValue<string> | null,
      delegator?: PromiseOrValue<string> | null,
      tokens?: null,
    ): StakeDelegatedWithdrawnEventFilter;

    "ThawRequestCreated(uint8,address,address,address,uint256,uint64,bytes32,uint256)"(
      requestType?: PromiseOrValue<BigNumberish> | null,
      serviceProvider?: PromiseOrValue<string> | null,
      verifier?: PromiseOrValue<string> | null,
      owner?: null,
      shares?: null,
      thawingUntil?: null,
      thawRequestId?: null,
      nonce?: null,
    ): ThawRequestCreatedEventFilter;
    ThawRequestCreated(
      requestType?: PromiseOrValue<BigNumberish> | null,
      serviceProvider?: PromiseOrValue<string> | null,
      verifier?: PromiseOrValue<string> | null,
      owner?: null,
      shares?: null,
      thawingUntil?: null,
      thawRequestId?: null,
      nonce?: null,
    ): ThawRequestCreatedEventFilter;

    "ThawRequestFulfilled(uint8,bytes32,uint256,uint256,uint64,bool)"(
      requestType?: PromiseOrValue<BigNumberish> | null,
      thawRequestId?: PromiseOrValue<BytesLike> | null,
      tokens?: null,
      shares?: null,
      thawingUntil?: null,
      valid?: null,
    ): ThawRequestFulfilledEventFilter;
    ThawRequestFulfilled(
      requestType?: PromiseOrValue<BigNumberish> | null,
      thawRequestId?: PromiseOrValue<BytesLike> | null,
      tokens?: null,
      shares?: null,
      thawingUntil?: null,
      valid?: null,
    ): ThawRequestFulfilledEventFilter;

    "ThawRequestsFulfilled(uint8,address,address,address,uint256,uint256)"(
      requestType?: PromiseOrValue<BigNumberish> | null,
      serviceProvider?: PromiseOrValue<string> | null,
      verifier?: PromiseOrValue<string> | null,
      owner?: null,
      thawRequestsFulfilled?: null,
      tokens?: null,
    ): ThawRequestsFulfilledEventFilter;
    ThawRequestsFulfilled(
      requestType?: PromiseOrValue<BigNumberish> | null,
      serviceProvider?: PromiseOrValue<string> | null,
      verifier?: PromiseOrValue<string> | null,
      owner?: null,
      thawRequestsFulfilled?: null,
      tokens?: null,
    ): ThawRequestsFulfilledEventFilter;

    "ThawingPeriodCleared()"(): ThawingPeriodClearedEventFilter;
    ThawingPeriodCleared(): ThawingPeriodClearedEventFilter;

    "TokensDelegated(address,address,address,uint256,uint256)"(
      serviceProvider?: PromiseOrValue<string> | null,
      verifier?: PromiseOrValue<string> | null,
      delegator?: PromiseOrValue<string> | null,
      tokens?: null,
      shares?: null,
    ): TokensDelegatedEventFilter;
    TokensDelegated(
      serviceProvider?: PromiseOrValue<string> | null,
      verifier?: PromiseOrValue<string> | null,
      delegator?: PromiseOrValue<string> | null,
      tokens?: null,
      shares?: null,
    ): TokensDelegatedEventFilter;

    "TokensDeprovisioned(address,address,uint256)"(
      serviceProvider?: PromiseOrValue<string> | null,
      verifier?: PromiseOrValue<string> | null,
      tokens?: null,
    ): TokensDeprovisionedEventFilter;
    TokensDeprovisioned(
      serviceProvider?: PromiseOrValue<string> | null,
      verifier?: PromiseOrValue<string> | null,
      tokens?: null,
    ): TokensDeprovisionedEventFilter;

    "TokensToDelegationPoolAdded(address,address,uint256)"(
      serviceProvider?: PromiseOrValue<string> | null,
      verifier?: PromiseOrValue<string> | null,
      tokens?: null,
    ): TokensToDelegationPoolAddedEventFilter;
    TokensToDelegationPoolAdded(
      serviceProvider?: PromiseOrValue<string> | null,
      verifier?: PromiseOrValue<string> | null,
      tokens?: null,
    ): TokensToDelegationPoolAddedEventFilter;

    "TokensUndelegated(address,address,address,uint256,uint256)"(
      serviceProvider?: PromiseOrValue<string> | null,
      verifier?: PromiseOrValue<string> | null,
      delegator?: PromiseOrValue<string> | null,
      tokens?: null,
      shares?: null,
    ): TokensUndelegatedEventFilter;
    TokensUndelegated(
      serviceProvider?: PromiseOrValue<string> | null,
      verifier?: PromiseOrValue<string> | null,
      delegator?: PromiseOrValue<string> | null,
      tokens?: null,
      shares?: null,
    ): TokensUndelegatedEventFilter;

    "VerifierTokensSent(address,address,address,uint256)"(
      serviceProvider?: PromiseOrValue<string> | null,
      verifier?: PromiseOrValue<string> | null,
      destination?: PromiseOrValue<string> | null,
      tokens?: null,
    ): VerifierTokensSentEventFilter;
    VerifierTokensSent(
      serviceProvider?: PromiseOrValue<string> | null,
      verifier?: PromiseOrValue<string> | null,
      destination?: PromiseOrValue<string> | null,
      tokens?: null,
    ): VerifierTokensSentEventFilter;
  };

  estimateGas: {
    acceptProvisionParameters(
      serviceProvider: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<BigNumber>;

    addToDelegationPool(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      tokens: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<BigNumber>;

    addToProvision(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      tokens: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<BigNumber>;

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

    "delegate(address,uint256)"(
      serviceProvider: PromiseOrValue<string>,
      tokens: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<BigNumber>;

    "delegate(address,address,uint256,uint256)"(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      tokens: PromiseOrValue<BigNumberish>,
      minSharesOut: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<BigNumber>;

    deprovision(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      nThawRequests: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<BigNumber>;

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

    isAuthorized(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      operator: PromiseOrValue<string>,
      overrides?: CallOverrides,
    ): Promise<BigNumber>;

    provision(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      tokens: PromiseOrValue<BigNumberish>,
      maxVerifierCut: PromiseOrValue<BigNumberish>,
      thawingPeriod: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<BigNumber>;

    provisionLocked(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      tokens: PromiseOrValue<BigNumberish>,
      maxVerifierCut: PromiseOrValue<BigNumberish>,
      thawingPeriod: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<BigNumber>;

    redelegate(
      oldServiceProvider: PromiseOrValue<string>,
      oldVerifier: PromiseOrValue<string>,
      newServiceProvider: PromiseOrValue<string>,
      newVerifier: PromiseOrValue<string>,
      minSharesForNewProvider: PromiseOrValue<BigNumberish>,
      nThawRequests: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<BigNumber>;

    reprovision(
      serviceProvider: PromiseOrValue<string>,
      oldVerifier: PromiseOrValue<string>,
      newVerifier: PromiseOrValue<string>,
      nThawRequests: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<BigNumber>;

    setAllowedLockedVerifier(
      verifier: PromiseOrValue<string>,
      allowed: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<BigNumber>;

    setDelegationFeeCut(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      paymentType: PromiseOrValue<BigNumberish>,
      feeCut: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<BigNumber>;

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

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

    setOperator(
      verifier: PromiseOrValue<string>,
      operator: PromiseOrValue<string>,
      allowed: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<BigNumber>;

    setOperatorLocked(
      verifier: PromiseOrValue<string>,
      operator: PromiseOrValue<string>,
      allowed: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<BigNumber>;

    setProvisionParameters(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      maxVerifierCut: PromiseOrValue<BigNumberish>,
      thawingPeriod: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<BigNumber>;

    slash(
      serviceProvider: PromiseOrValue<string>,
      tokens: PromiseOrValue<BigNumberish>,
      tokensVerifier: PromiseOrValue<BigNumberish>,
      verifierDestination: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<BigNumber>;

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

    stakeTo(
      serviceProvider: PromiseOrValue<string>,
      tokens: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<BigNumber>;

    stakeToProvision(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      tokens: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<BigNumber>;

    thaw(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      tokens: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<BigNumber>;

    "undelegate(address,uint256)"(
      serviceProvider: PromiseOrValue<string>,
      shares: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<BigNumber>;

    "undelegate(address,address,uint256)"(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      shares: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<BigNumber>;

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

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

    "withdrawDelegated(address,address,uint256)"(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      nThawRequests: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<BigNumber>;

    "withdrawDelegated(address,address)"(
      serviceProvider: PromiseOrValue<string>,
      deprecated: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<BigNumber>;
  };

  populateTransaction: {
    acceptProvisionParameters(
      serviceProvider: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<PopulatedTransaction>;

    addToDelegationPool(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      tokens: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<PopulatedTransaction>;

    addToProvision(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      tokens: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<PopulatedTransaction>;

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

    "delegate(address,uint256)"(
      serviceProvider: PromiseOrValue<string>,
      tokens: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<PopulatedTransaction>;

    "delegate(address,address,uint256,uint256)"(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      tokens: PromiseOrValue<BigNumberish>,
      minSharesOut: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<PopulatedTransaction>;

    deprovision(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      nThawRequests: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<PopulatedTransaction>;

    getStakingExtension(
      overrides?: CallOverrides,
    ): Promise<PopulatedTransaction>;

    isAuthorized(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      operator: PromiseOrValue<string>,
      overrides?: CallOverrides,
    ): Promise<PopulatedTransaction>;

    provision(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      tokens: PromiseOrValue<BigNumberish>,
      maxVerifierCut: PromiseOrValue<BigNumberish>,
      thawingPeriod: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<PopulatedTransaction>;

    provisionLocked(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      tokens: PromiseOrValue<BigNumberish>,
      maxVerifierCut: PromiseOrValue<BigNumberish>,
      thawingPeriod: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<PopulatedTransaction>;

    redelegate(
      oldServiceProvider: PromiseOrValue<string>,
      oldVerifier: PromiseOrValue<string>,
      newServiceProvider: PromiseOrValue<string>,
      newVerifier: PromiseOrValue<string>,
      minSharesForNewProvider: PromiseOrValue<BigNumberish>,
      nThawRequests: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<PopulatedTransaction>;

    reprovision(
      serviceProvider: PromiseOrValue<string>,
      oldVerifier: PromiseOrValue<string>,
      newVerifier: PromiseOrValue<string>,
      nThawRequests: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<PopulatedTransaction>;

    setAllowedLockedVerifier(
      verifier: PromiseOrValue<string>,
      allowed: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<PopulatedTransaction>;

    setDelegationFeeCut(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      paymentType: PromiseOrValue<BigNumberish>,
      feeCut: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<PopulatedTransaction>;

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

    setMaxThawingPeriod(
      maxThawingPeriod: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<PopulatedTransaction>;

    setOperator(
      verifier: PromiseOrValue<string>,
      operator: PromiseOrValue<string>,
      allowed: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<PopulatedTransaction>;

    setOperatorLocked(
      verifier: PromiseOrValue<string>,
      operator: PromiseOrValue<string>,
      allowed: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<PopulatedTransaction>;

    setProvisionParameters(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      maxVerifierCut: PromiseOrValue<BigNumberish>,
      thawingPeriod: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<PopulatedTransaction>;

    slash(
      serviceProvider: PromiseOrValue<string>,
      tokens: PromiseOrValue<BigNumberish>,
      tokensVerifier: PromiseOrValue<BigNumberish>,
      verifierDestination: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<PopulatedTransaction>;

    stake(
      tokens: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<PopulatedTransaction>;

    stakeTo(
      serviceProvider: PromiseOrValue<string>,
      tokens: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<PopulatedTransaction>;

    stakeToProvision(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      tokens: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<PopulatedTransaction>;

    thaw(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      tokens: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<PopulatedTransaction>;

    "undelegate(address,uint256)"(
      serviceProvider: PromiseOrValue<string>,
      shares: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<PopulatedTransaction>;

    "undelegate(address,address,uint256)"(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      shares: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<PopulatedTransaction>;

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

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

    "withdrawDelegated(address,address,uint256)"(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      nThawRequests: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<PopulatedTransaction>;

    "withdrawDelegated(address,address)"(
      serviceProvider: PromiseOrValue<string>,
      deprecated: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<PopulatedTransaction>;
  };
}
