/* 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 IHorizonStakingExtension {
  export type AllocationStruct = {
    indexer: PromiseOrValue<string>;
    subgraphDeploymentID: PromiseOrValue<BytesLike>;
    tokens: PromiseOrValue<BigNumberish>;
    createdAtEpoch: PromiseOrValue<BigNumberish>;
    closedAtEpoch: PromiseOrValue<BigNumberish>;
    collectedFees: PromiseOrValue<BigNumberish>;
    __DEPRECATED_effectiveAllocation: PromiseOrValue<BigNumberish>;
    accRewardsPerAllocatedToken: PromiseOrValue<BigNumberish>;
    distributedRebates: PromiseOrValue<BigNumberish>;
  };

  export type AllocationStructOutput = [
    string,
    string,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber
  ] & {
    indexer: string;
    subgraphDeploymentID: string;
    tokens: BigNumber;
    createdAtEpoch: BigNumber;
    closedAtEpoch: BigNumber;
    collectedFees: BigNumber;
    __DEPRECATED_effectiveAllocation: BigNumber;
    accRewardsPerAllocatedToken: BigNumber;
    distributedRebates: BigNumber;
  };
}

export declare namespace IHorizonStakingTypes {
  export type DelegationStruct = { shares: PromiseOrValue<BigNumberish> };

  export type DelegationStructOutput = [BigNumber] & { shares: BigNumber };

  export type DelegationPoolStruct = {
    tokens: PromiseOrValue<BigNumberish>;
    shares: PromiseOrValue<BigNumberish>;
    tokensThawing: PromiseOrValue<BigNumberish>;
    sharesThawing: PromiseOrValue<BigNumberish>;
    thawingNonce: PromiseOrValue<BigNumberish>;
  };

  export type DelegationPoolStructOutput = [
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber
  ] & {
    tokens: BigNumber;
    shares: BigNumber;
    tokensThawing: BigNumber;
    sharesThawing: BigNumber;
    thawingNonce: BigNumber;
  };

  export type ProvisionStruct = {
    tokens: PromiseOrValue<BigNumberish>;
    tokensThawing: PromiseOrValue<BigNumberish>;
    sharesThawing: PromiseOrValue<BigNumberish>;
    maxVerifierCut: PromiseOrValue<BigNumberish>;
    thawingPeriod: PromiseOrValue<BigNumberish>;
    createdAt: PromiseOrValue<BigNumberish>;
    maxVerifierCutPending: PromiseOrValue<BigNumberish>;
    thawingPeriodPending: PromiseOrValue<BigNumberish>;
    lastParametersStagedAt: PromiseOrValue<BigNumberish>;
    thawingNonce: PromiseOrValue<BigNumberish>;
  };

  export type ProvisionStructOutput = [
    BigNumber,
    BigNumber,
    BigNumber,
    number,
    BigNumber,
    BigNumber,
    number,
    BigNumber,
    BigNumber,
    BigNumber
  ] & {
    tokens: BigNumber;
    tokensThawing: BigNumber;
    sharesThawing: BigNumber;
    maxVerifierCut: number;
    thawingPeriod: BigNumber;
    createdAt: BigNumber;
    maxVerifierCutPending: number;
    thawingPeriodPending: BigNumber;
    lastParametersStagedAt: BigNumber;
    thawingNonce: BigNumber;
  };

  export type ServiceProviderStruct = {
    tokensStaked: PromiseOrValue<BigNumberish>;
    tokensProvisioned: PromiseOrValue<BigNumberish>;
  };

  export type ServiceProviderStructOutput = [BigNumber, BigNumber] & {
    tokensStaked: BigNumber;
    tokensProvisioned: BigNumber;
  };

  export type ThawRequestStruct = {
    shares: PromiseOrValue<BigNumberish>;
    thawingUntil: PromiseOrValue<BigNumberish>;
    nextRequest: PromiseOrValue<BytesLike>;
    thawingNonce: PromiseOrValue<BigNumberish>;
  };

  export type ThawRequestStructOutput = [
    BigNumber,
    BigNumber,
    string,
    BigNumber
  ] & {
    shares: BigNumber;
    thawingUntil: BigNumber;
    nextRequest: string;
    thawingNonce: BigNumber;
  };
}

export declare namespace ILinkedList {
  export type ListStruct = {
    head: PromiseOrValue<BytesLike>;
    tail: PromiseOrValue<BytesLike>;
    nonce: PromiseOrValue<BigNumberish>;
    count: PromiseOrValue<BigNumberish>;
  };

  export type ListStructOutput = [string, string, BigNumber, BigNumber] & {
    head: string;
    tail: string;
    nonce: BigNumber;
    count: BigNumber;
  };
}

export interface IHorizonStakingToolshedInterface extends utils.Interface {
  functions: {
    "__DEPRECATED_getThawingPeriod()": FunctionFragment;
    "acceptProvisionParameters(address)": FunctionFragment;
    "addToDelegationPool(address,address,uint256)": FunctionFragment;
    "addToProvision(address,address,uint256)": FunctionFragment;
    "clearThawingPeriod()": FunctionFragment;
    "closeAllocation(address,bytes32)": FunctionFragment;
    "collect(uint256,address)": FunctionFragment;
    "delegate(address,uint256)": FunctionFragment;
    "delegate(address,address,uint256,uint256)": FunctionFragment;
    "deprovision(address,address,uint256)": FunctionFragment;
    "getAllocation(address)": FunctionFragment;
    "getAllocationData(address)": FunctionFragment;
    "getAllocationState(address)": FunctionFragment;
    "getDelegatedTokensAvailable(address,address)": FunctionFragment;
    "getDelegation(address,address,address)": FunctionFragment;
    "getDelegationFeeCut(address,address,uint8)": FunctionFragment;
    "getDelegationPool(address,address)": FunctionFragment;
    "getIdleStake(address)": FunctionFragment;
    "getIndexerStakedTokens(address)": FunctionFragment;
    "getMaxThawingPeriod()": FunctionFragment;
    "getProviderTokensAvailable(address,address)": FunctionFragment;
    "getProvision(address,address)": FunctionFragment;
    "getServiceProvider(address)": FunctionFragment;
    "getStake(address)": FunctionFragment;
    "getStakingExtension()": FunctionFragment;
    "getSubgraphAllocatedTokens(bytes32)": FunctionFragment;
    "getSubgraphService()": FunctionFragment;
    "getThawRequest(uint8,bytes32)": FunctionFragment;
    "getThawRequestList(uint8,address,address,address)": FunctionFragment;
    "getThawedTokens(uint8,address,address,address)": FunctionFragment;
    "getTokensAvailable(address,address,uint32)": FunctionFragment;
    "hasStake(address)": FunctionFragment;
    "isAllocation(address)": FunctionFragment;
    "isAllowedLockedVerifier(address)": FunctionFragment;
    "isAuthorized(address,address,address)": FunctionFragment;
    "isDelegationSlashingEnabled()": FunctionFragment;
    "isOperator(address,address)": FunctionFragment;
    "legacySlash(address,uint256,uint256,address)": FunctionFragment;
    "multicall(bytes[])": 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:
      | "__DEPRECATED_getThawingPeriod"
      | "acceptProvisionParameters"
      | "addToDelegationPool"
      | "addToProvision"
      | "clearThawingPeriod"
      | "closeAllocation"
      | "collect"
      | "delegate(address,uint256)"
      | "delegate(address,address,uint256,uint256)"
      | "deprovision"
      | "getAllocation"
      | "getAllocationData"
      | "getAllocationState"
      | "getDelegatedTokensAvailable"
      | "getDelegation"
      | "getDelegationFeeCut"
      | "getDelegationPool"
      | "getIdleStake"
      | "getIndexerStakedTokens"
      | "getMaxThawingPeriod"
      | "getProviderTokensAvailable"
      | "getProvision"
      | "getServiceProvider"
      | "getStake"
      | "getStakingExtension"
      | "getSubgraphAllocatedTokens"
      | "getSubgraphService"
      | "getThawRequest"
      | "getThawRequestList"
      | "getThawedTokens"
      | "getTokensAvailable"
      | "hasStake"
      | "isAllocation"
      | "isAllowedLockedVerifier"
      | "isAuthorized"
      | "isDelegationSlashingEnabled"
      | "isOperator"
      | "legacySlash"
      | "multicall"
      | "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: "__DEPRECATED_getThawingPeriod",
    values?: undefined
  ): string;
  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: "closeAllocation",
    values: [PromiseOrValue<string>, PromiseOrValue<BytesLike>]
  ): string;
  encodeFunctionData(
    functionFragment: "collect",
    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<string>]
  ): 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: "getAllocation",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "getAllocationData",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "getAllocationState",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "getDelegatedTokensAvailable",
    values: [PromiseOrValue<string>, PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "getDelegation",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<string>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "getDelegationFeeCut",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "getDelegationPool",
    values: [PromiseOrValue<string>, PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "getIdleStake",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "getIndexerStakedTokens",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "getMaxThawingPeriod",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getProviderTokensAvailable",
    values: [PromiseOrValue<string>, PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "getProvision",
    values: [PromiseOrValue<string>, PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "getServiceProvider",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "getStake",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "getStakingExtension",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getSubgraphAllocatedTokens",
    values: [PromiseOrValue<BytesLike>]
  ): string;
  encodeFunctionData(
    functionFragment: "getSubgraphService",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getThawRequest",
    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BytesLike>]
  ): string;
  encodeFunctionData(
    functionFragment: "getThawRequestList",
    values: [
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<string>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "getThawedTokens",
    values: [
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<string>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "getTokensAvailable",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "hasStake",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "isAllocation",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "isAllowedLockedVerifier",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "isAuthorized",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<string>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "isDelegationSlashingEnabled",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "isOperator",
    values: [PromiseOrValue<string>, PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "legacySlash",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<string>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "multicall",
    values: [PromiseOrValue<BytesLike>[]]
  ): 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: "__DEPRECATED_getThawingPeriod",
    data: BytesLike
  ): Result;
  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: "closeAllocation",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "collect", 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: "getAllocation",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getAllocationData",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getAllocationState",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getDelegatedTokensAvailable",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getDelegation",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getDelegationFeeCut",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getDelegationPool",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getIdleStake",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getIndexerStakedTokens",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getMaxThawingPeriod",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getProviderTokensAvailable",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getProvision",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getServiceProvider",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "getStake", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getStakingExtension",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getSubgraphAllocatedTokens",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getSubgraphService",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getThawRequest",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getThawRequestList",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getThawedTokens",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getTokensAvailable",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "hasStake", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "isAllocation",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isAllowedLockedVerifier",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isAuthorized",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isDelegationSlashingEnabled",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "isOperator", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "legacySlash",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "multicall", 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: {
    "AllocationClosed(address,bytes32,uint256,uint256,address,address,bytes32,bool)": EventFragment;
    "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;
    "HorizonStakeDeposited(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;
    "RebateCollected(address,address,bytes32,address,uint256,uint256,uint256,uint256,uint256,uint256,uint256)": EventFragment;
    "StakeDelegatedWithdrawn(address,address,uint256)": EventFragment;
    "StakeSlashed(address,uint256,uint256,address)": 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: "AllocationClosed"): 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: "HorizonStakeDeposited"): 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: "RebateCollected"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "StakeDelegatedWithdrawn"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "StakeSlashed"): 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 AllocationClosedEventObject {
  indexer: string;
  subgraphDeploymentID: string;
  epoch: BigNumber;
  tokens: BigNumber;
  allocationID: string;
  sender: string;
  poi: string;
  isPublic: boolean;
}
export type AllocationClosedEvent = TypedEvent<
  [string, string, BigNumber, BigNumber, string, string, string, boolean],
  AllocationClosedEventObject
>;

export type AllocationClosedEventFilter =
  TypedEventFilter<AllocationClosedEvent>;

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 HorizonStakeDepositedEventObject {
  serviceProvider: string;
  tokens: BigNumber;
}
export type HorizonStakeDepositedEvent = TypedEvent<
  [string, BigNumber],
  HorizonStakeDepositedEventObject
>;

export type HorizonStakeDepositedEventFilter =
  TypedEventFilter<HorizonStakeDepositedEvent>;

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 RebateCollectedEventObject {
  assetHolder: string;
  indexer: string;
  subgraphDeploymentID: string;
  allocationID: string;
  epoch: BigNumber;
  tokens: BigNumber;
  protocolTax: BigNumber;
  curationFees: BigNumber;
  queryFees: BigNumber;
  queryRebates: BigNumber;
  delegationRewards: BigNumber;
}
export type RebateCollectedEvent = TypedEvent<
  [
    string,
    string,
    string,
    string,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber
  ],
  RebateCollectedEventObject
>;

export type RebateCollectedEventFilter = TypedEventFilter<RebateCollectedEvent>;

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

export type StakeDelegatedWithdrawnEventFilter =
  TypedEventFilter<StakeDelegatedWithdrawnEvent>;

export interface StakeSlashedEventObject {
  indexer: string;
  tokens: BigNumber;
  reward: BigNumber;
  beneficiary: string;
}
export type StakeSlashedEvent = TypedEvent<
  [string, BigNumber, BigNumber, string],
  StakeSlashedEventObject
>;

export type StakeSlashedEventFilter = TypedEventFilter<StakeSlashedEvent>;

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 IHorizonStakingToolshed extends BaseContract {
  connect(signerOrProvider: Signer | Provider | string): this;
  attach(addressOrName: string): this;
  deployed(): Promise<this>;

  interface: IHorizonStakingToolshedInterface;

  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: {
    __DEPRECATED_getThawingPeriod(
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

    closeAllocation(
      allocationID: PromiseOrValue<string>,
      poi: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    collect(
      tokens: PromiseOrValue<BigNumberish>,
      allocationID: PromiseOrValue<string>,
      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>;

    getAllocation(
      allocationID: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[IHorizonStakingExtension.AllocationStructOutput]>;

    getAllocationData(
      allocationId: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<
      [boolean, string, string, BigNumber, BigNumber, BigNumber] & {
        isActive: boolean;
        indexer: string;
        subgraphDeploymentId: string;
        tokens: BigNumber;
        accRewardsPerAllocatedToken: BigNumber;
        accRewardsPending: BigNumber;
      }
    >;

    getAllocationState(
      allocationID: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[number]>;

    getDelegatedTokensAvailable(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    getDelegation(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      delegator: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[IHorizonStakingTypes.DelegationStructOutput]>;

    getDelegationFeeCut(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      paymentType: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    getDelegationPool(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[IHorizonStakingTypes.DelegationPoolStructOutput]>;

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

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

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

    getProviderTokensAvailable(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    getProvision(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[IHorizonStakingTypes.ProvisionStructOutput]>;

    getServiceProvider(
      serviceProvider: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[IHorizonStakingTypes.ServiceProviderStructOutput]>;

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

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

    getSubgraphAllocatedTokens(
      subgraphDeploymentId: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

    getThawRequest(
      thawRequestType: PromiseOrValue<BigNumberish>,
      thawRequestId: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<[IHorizonStakingTypes.ThawRequestStructOutput]>;

    getThawRequestList(
      thawRequestType: PromiseOrValue<BigNumberish>,
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      owner: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[ILinkedList.ListStructOutput]>;

    getThawedTokens(
      thawRequestType: PromiseOrValue<BigNumberish>,
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      owner: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    getTokensAvailable(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      delegationRatio: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

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

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

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

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

    isOperator(
      operator: PromiseOrValue<string>,
      indexer: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

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

    multicall(
      data: PromiseOrValue<BytesLike>[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

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

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

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

  closeAllocation(
    allocationID: PromiseOrValue<string>,
    poi: PromiseOrValue<BytesLike>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  collect(
    tokens: PromiseOrValue<BigNumberish>,
    allocationID: PromiseOrValue<string>,
    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>;

  getAllocation(
    allocationID: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<IHorizonStakingExtension.AllocationStructOutput>;

  getAllocationData(
    allocationId: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<
    [boolean, string, string, BigNumber, BigNumber, BigNumber] & {
      isActive: boolean;
      indexer: string;
      subgraphDeploymentId: string;
      tokens: BigNumber;
      accRewardsPerAllocatedToken: BigNumber;
      accRewardsPending: BigNumber;
    }
  >;

  getAllocationState(
    allocationID: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<number>;

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

  getDelegation(
    serviceProvider: PromiseOrValue<string>,
    verifier: PromiseOrValue<string>,
    delegator: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<IHorizonStakingTypes.DelegationStructOutput>;

  getDelegationFeeCut(
    serviceProvider: PromiseOrValue<string>,
    verifier: PromiseOrValue<string>,
    paymentType: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  getDelegationPool(
    serviceProvider: PromiseOrValue<string>,
    verifier: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<IHorizonStakingTypes.DelegationPoolStructOutput>;

  getIdleStake(
    serviceProvider: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  getIndexerStakedTokens(
    indexer: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

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

  getProvision(
    serviceProvider: PromiseOrValue<string>,
    verifier: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<IHorizonStakingTypes.ProvisionStructOutput>;

  getServiceProvider(
    serviceProvider: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<IHorizonStakingTypes.ServiceProviderStructOutput>;

  getStake(
    serviceProvider: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

  getSubgraphAllocatedTokens(
    subgraphDeploymentId: PromiseOrValue<BytesLike>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

  getThawRequest(
    thawRequestType: PromiseOrValue<BigNumberish>,
    thawRequestId: PromiseOrValue<BytesLike>,
    overrides?: CallOverrides
  ): Promise<IHorizonStakingTypes.ThawRequestStructOutput>;

  getThawRequestList(
    thawRequestType: PromiseOrValue<BigNumberish>,
    serviceProvider: PromiseOrValue<string>,
    verifier: PromiseOrValue<string>,
    owner: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<ILinkedList.ListStructOutput>;

  getThawedTokens(
    thawRequestType: PromiseOrValue<BigNumberish>,
    serviceProvider: PromiseOrValue<string>,
    verifier: PromiseOrValue<string>,
    owner: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  getTokensAvailable(
    serviceProvider: PromiseOrValue<string>,
    verifier: PromiseOrValue<string>,
    delegationRatio: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  hasStake(
    indexer: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<boolean>;

  isAllocation(
    allocationID: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<boolean>;

  isAllowedLockedVerifier(
    verifier: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<boolean>;

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

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

  isOperator(
    operator: PromiseOrValue<string>,
    indexer: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<boolean>;

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

  multicall(
    data: PromiseOrValue<BytesLike>[],
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  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: {
    __DEPRECATED_getThawingPeriod(
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    closeAllocation(
      allocationID: PromiseOrValue<string>,
      poi: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<void>;

    collect(
      tokens: PromiseOrValue<BigNumberish>,
      allocationID: PromiseOrValue<string>,
      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>;

    getAllocation(
      allocationID: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<IHorizonStakingExtension.AllocationStructOutput>;

    getAllocationData(
      allocationId: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<
      [boolean, string, string, BigNumber, BigNumber, BigNumber] & {
        isActive: boolean;
        indexer: string;
        subgraphDeploymentId: string;
        tokens: BigNumber;
        accRewardsPerAllocatedToken: BigNumber;
        accRewardsPending: BigNumber;
      }
    >;

    getAllocationState(
      allocationID: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<number>;

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

    getDelegation(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      delegator: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<IHorizonStakingTypes.DelegationStructOutput>;

    getDelegationFeeCut(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      paymentType: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getDelegationPool(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<IHorizonStakingTypes.DelegationPoolStructOutput>;

    getIdleStake(
      serviceProvider: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getIndexerStakedTokens(
      indexer: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    getProvision(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<IHorizonStakingTypes.ProvisionStructOutput>;

    getServiceProvider(
      serviceProvider: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<IHorizonStakingTypes.ServiceProviderStructOutput>;

    getStake(
      serviceProvider: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    getSubgraphAllocatedTokens(
      subgraphDeploymentId: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    getThawRequest(
      thawRequestType: PromiseOrValue<BigNumberish>,
      thawRequestId: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<IHorizonStakingTypes.ThawRequestStructOutput>;

    getThawRequestList(
      thawRequestType: PromiseOrValue<BigNumberish>,
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      owner: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<ILinkedList.ListStructOutput>;

    getThawedTokens(
      thawRequestType: PromiseOrValue<BigNumberish>,
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      owner: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getTokensAvailable(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      delegationRatio: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    hasStake(
      indexer: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<boolean>;

    isAllocation(
      allocationID: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<boolean>;

    isAllowedLockedVerifier(
      verifier: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

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

    isOperator(
      operator: PromiseOrValue<string>,
      indexer: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<boolean>;

    legacySlash(
      indexer: PromiseOrValue<string>,
      tokens: PromiseOrValue<BigNumberish>,
      reward: PromiseOrValue<BigNumberish>,
      beneficiary: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    multicall(
      data: PromiseOrValue<BytesLike>[],
      overrides?: CallOverrides
    ): Promise<string[]>;

    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: {
    "AllocationClosed(address,bytes32,uint256,uint256,address,address,bytes32,bool)"(
      indexer?: PromiseOrValue<string> | null,
      subgraphDeploymentID?: PromiseOrValue<BytesLike> | null,
      epoch?: null,
      tokens?: null,
      allocationID?: PromiseOrValue<string> | null,
      sender?: null,
      poi?: null,
      isPublic?: null
    ): AllocationClosedEventFilter;
    AllocationClosed(
      indexer?: PromiseOrValue<string> | null,
      subgraphDeploymentID?: PromiseOrValue<BytesLike> | null,
      epoch?: null,
      tokens?: null,
      allocationID?: PromiseOrValue<string> | null,
      sender?: null,
      poi?: null,
      isPublic?: null
    ): AllocationClosedEventFilter;

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

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

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

    "RebateCollected(address,address,bytes32,address,uint256,uint256,uint256,uint256,uint256,uint256,uint256)"(
      assetHolder?: null,
      indexer?: PromiseOrValue<string> | null,
      subgraphDeploymentID?: PromiseOrValue<BytesLike> | null,
      allocationID?: PromiseOrValue<string> | null,
      epoch?: null,
      tokens?: null,
      protocolTax?: null,
      curationFees?: null,
      queryFees?: null,
      queryRebates?: null,
      delegationRewards?: null
    ): RebateCollectedEventFilter;
    RebateCollected(
      assetHolder?: null,
      indexer?: PromiseOrValue<string> | null,
      subgraphDeploymentID?: PromiseOrValue<BytesLike> | null,
      allocationID?: PromiseOrValue<string> | null,
      epoch?: null,
      tokens?: null,
      protocolTax?: null,
      curationFees?: null,
      queryFees?: null,
      queryRebates?: null,
      delegationRewards?: null
    ): RebateCollectedEventFilter;

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

    "StakeSlashed(address,uint256,uint256,address)"(
      indexer?: PromiseOrValue<string> | null,
      tokens?: null,
      reward?: null,
      beneficiary?: null
    ): StakeSlashedEventFilter;
    StakeSlashed(
      indexer?: PromiseOrValue<string> | null,
      tokens?: null,
      reward?: null,
      beneficiary?: null
    ): StakeSlashedEventFilter;

    "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: {
    __DEPRECATED_getThawingPeriod(
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    closeAllocation(
      allocationID: PromiseOrValue<string>,
      poi: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    collect(
      tokens: PromiseOrValue<BigNumberish>,
      allocationID: PromiseOrValue<string>,
      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>;

    getAllocation(
      allocationID: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getAllocationData(
      allocationId: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getAllocationState(
      allocationID: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    getDelegationFeeCut(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      paymentType: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    getIdleStake(
      serviceProvider: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getIndexerStakedTokens(
      indexer: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

    getServiceProvider(
      serviceProvider: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getStake(
      serviceProvider: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    getSubgraphAllocatedTokens(
      subgraphDeploymentId: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    getThawRequest(
      thawRequestType: PromiseOrValue<BigNumberish>,
      thawRequestId: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getThawRequestList(
      thawRequestType: PromiseOrValue<BigNumberish>,
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      owner: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getThawedTokens(
      thawRequestType: PromiseOrValue<BigNumberish>,
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      owner: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getTokensAvailable(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      delegationRatio: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    hasStake(
      indexer: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    isAllocation(
      allocationID: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    isAllowedLockedVerifier(
      verifier: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

    multicall(
      data: PromiseOrValue<BytesLike>[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): 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: {
    __DEPRECATED_getThawingPeriod(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    closeAllocation(
      allocationID: PromiseOrValue<string>,
      poi: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    collect(
      tokens: PromiseOrValue<BigNumberish>,
      allocationID: PromiseOrValue<string>,
      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>;

    getAllocation(
      allocationID: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getAllocationData(
      allocationId: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getAllocationState(
      allocationID: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    getDelegationFeeCut(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      paymentType: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    getIdleStake(
      serviceProvider: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getIndexerStakedTokens(
      indexer: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

    getServiceProvider(
      serviceProvider: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getStake(
      serviceProvider: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    getSubgraphAllocatedTokens(
      subgraphDeploymentId: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    getThawRequest(
      thawRequestType: PromiseOrValue<BigNumberish>,
      thawRequestId: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getThawRequestList(
      thawRequestType: PromiseOrValue<BigNumberish>,
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      owner: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getThawedTokens(
      thawRequestType: PromiseOrValue<BigNumberish>,
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      owner: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getTokensAvailable(
      serviceProvider: PromiseOrValue<string>,
      verifier: PromiseOrValue<string>,
      delegationRatio: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    hasStake(
      indexer: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    isAllocation(
      allocationID: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    isAllowedLockedVerifier(
      verifier: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

    multicall(
      data: PromiseOrValue<BytesLike>[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): 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>;
  };
}