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

import {
  ethers,
  EventFilter,
  Signer,
  BigNumber,
  BigNumberish,
  PopulatedTransaction,
  BaseContract,
  ContractTransaction,
  Overrides,
  CallOverrides,
} from "ethers";
import { BytesLike } from "@ethersproject/bytes";
import { Listener, Provider } from "@ethersproject/providers";
import { FunctionFragment, EventFragment, Result } from "@ethersproject/abi";
import { TypedEventFilter, TypedEvent, TypedListener } from "./commons";

interface IStakingInterface extends ethers.utils.Interface {
  functions: {
    "allocate(bytes32,uint256,address,bytes32,bytes)": FunctionFragment;
    "allocateFrom(address,bytes32,uint256,address,bytes32,bytes)": FunctionFragment;
    "claim(address,bool)": FunctionFragment;
    "claimMany(address[],bool)": FunctionFragment;
    "closeAllocation(address,bytes32)": FunctionFragment;
    "closeAllocationMany(tuple[])": FunctionFragment;
    "closeAndAllocate(address,bytes32,address,bytes32,uint256,address,bytes32,bytes)": FunctionFragment;
    "collect(uint256,address)": FunctionFragment;
    "delegate(address,uint256)": FunctionFragment;
    "getAllocation(address)": FunctionFragment;
    "getAllocationState(address)": FunctionFragment;
    "getDelegation(address,address)": FunctionFragment;
    "getIndexerCapacity(address)": FunctionFragment;
    "getIndexerStakedTokens(address)": FunctionFragment;
    "getSubgraphAllocatedTokens(bytes32)": FunctionFragment;
    "hasStake(address)": FunctionFragment;
    "isAllocation(address)": FunctionFragment;
    "isDelegator(address,address)": FunctionFragment;
    "isOperator(address,address)": FunctionFragment;
    "setAssetHolder(address,bool)": FunctionFragment;
    "setChannelDisputeEpochs(uint32)": FunctionFragment;
    "setCurationPercentage(uint32)": FunctionFragment;
    "setDelegationParameters(uint32,uint32,uint32)": FunctionFragment;
    "setDelegationParametersCooldown(uint32)": FunctionFragment;
    "setDelegationRatio(uint32)": FunctionFragment;
    "setDelegationTaxPercentage(uint32)": FunctionFragment;
    "setDelegationUnbondingPeriod(uint32)": FunctionFragment;
    "setMaxAllocationEpochs(uint32)": FunctionFragment;
    "setMinimumIndexerStake(uint256)": FunctionFragment;
    "setOperator(address,bool)": FunctionFragment;
    "setProtocolPercentage(uint32)": FunctionFragment;
    "setRebateRatio(uint32,uint32)": FunctionFragment;
    "setRewardsDestination(address)": FunctionFragment;
    "setSlasher(address,bool)": FunctionFragment;
    "setThawingPeriod(uint32)": FunctionFragment;
    "slash(address,uint256,uint256,address)": FunctionFragment;
    "stake(uint256)": FunctionFragment;
    "stakeTo(address,uint256)": FunctionFragment;
    "undelegate(address,uint256)": FunctionFragment;
    "unstake(uint256)": FunctionFragment;
    "withdraw()": FunctionFragment;
    "withdrawDelegated(address,address)": FunctionFragment;
  };

  encodeFunctionData(
    functionFragment: "allocate",
    values: [BytesLike, BigNumberish, string, BytesLike, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "allocateFrom",
    values: [string, BytesLike, BigNumberish, string, BytesLike, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "claim",
    values: [string, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "claimMany",
    values: [string[], boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "closeAllocation",
    values: [string, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "closeAllocationMany",
    values: [{ allocationID: string; poi: BytesLike }[]]
  ): string;
  encodeFunctionData(
    functionFragment: "closeAndAllocate",
    values: [
      string,
      BytesLike,
      string,
      BytesLike,
      BigNumberish,
      string,
      BytesLike,
      BytesLike
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "collect",
    values: [BigNumberish, string]
  ): string;
  encodeFunctionData(
    functionFragment: "delegate",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getAllocation",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "getAllocationState",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "getDelegation",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "getIndexerCapacity",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "getIndexerStakedTokens",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "getSubgraphAllocatedTokens",
    values: [BytesLike]
  ): string;
  encodeFunctionData(functionFragment: "hasStake", values: [string]): string;
  encodeFunctionData(
    functionFragment: "isAllocation",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "isDelegator",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "isOperator",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "setAssetHolder",
    values: [string, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "setChannelDisputeEpochs",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setCurationPercentage",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setDelegationParameters",
    values: [BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setDelegationParametersCooldown",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setDelegationRatio",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setDelegationTaxPercentage",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setDelegationUnbondingPeriod",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setMaxAllocationEpochs",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setMinimumIndexerStake",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setOperator",
    values: [string, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "setProtocolPercentage",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setRebateRatio",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setRewardsDestination",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setSlasher",
    values: [string, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "setThawingPeriod",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "slash",
    values: [string, BigNumberish, BigNumberish, string]
  ): string;
  encodeFunctionData(functionFragment: "stake", values: [BigNumberish]): string;
  encodeFunctionData(
    functionFragment: "stakeTo",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "undelegate",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "unstake",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "withdraw", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "withdrawDelegated",
    values: [string, string]
  ): string;

  decodeFunctionResult(functionFragment: "allocate", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "allocateFrom",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "claim", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "claimMany", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "closeAllocation",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "closeAllocationMany",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "closeAndAllocate",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "collect", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "delegate", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getAllocation",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getAllocationState",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getDelegation",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getIndexerCapacity",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getIndexerStakedTokens",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getSubgraphAllocatedTokens",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "hasStake", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "isAllocation",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isDelegator",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "isOperator", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setAssetHolder",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setChannelDisputeEpochs",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setCurationPercentage",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setDelegationParameters",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setDelegationParametersCooldown",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setDelegationRatio",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setDelegationTaxPercentage",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setDelegationUnbondingPeriod",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setMaxAllocationEpochs",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setMinimumIndexerStake",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setOperator",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setProtocolPercentage",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setRebateRatio",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setRewardsDestination",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "setSlasher", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setThawingPeriod",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "slash", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "stake", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "stakeTo", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "undelegate", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "unstake", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "withdrawDelegated",
    data: BytesLike
  ): Result;

  events: {};
}

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

  listeners<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter?: TypedEventFilter<EventArgsArray, EventArgsObject>
  ): Array<TypedListener<EventArgsArray, EventArgsObject>>;
  off<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  on<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  once<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  removeListener<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  removeAllListeners<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>
  ): this;

  listeners(eventName?: string): Array<Listener>;
  off(eventName: string, listener: Listener): this;
  on(eventName: string, listener: Listener): this;
  once(eventName: string, listener: Listener): this;
  removeListener(eventName: string, listener: Listener): this;
  removeAllListeners(eventName?: string): this;

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

  interface: IStakingInterface;

  functions: {
    allocate(
      _subgraphDeploymentID: BytesLike,
      _tokens: BigNumberish,
      _allocationID: string,
      _metadata: BytesLike,
      _proof: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    allocateFrom(
      _indexer: string,
      _subgraphDeploymentID: BytesLike,
      _tokens: BigNumberish,
      _allocationID: string,
      _metadata: BytesLike,
      _proof: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    claim(
      _allocationID: string,
      _restake: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    claimMany(
      _allocationID: string[],
      _restake: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    closeAllocation(
      _allocationID: string,
      _poi: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    closeAllocationMany(
      _requests: { allocationID: string; poi: BytesLike }[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    closeAndAllocate(
      _oldAllocationID: string,
      _poi: BytesLike,
      _indexer: string,
      _subgraphDeploymentID: BytesLike,
      _tokens: BigNumberish,
      _allocationID: string,
      _metadata: BytesLike,
      _proof: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    collect(
      _tokens: BigNumberish,
      _allocationID: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    getAllocation(
      _allocationID: string,
      overrides?: CallOverrides
    ): Promise<
      [
        [
          string,
          string,
          BigNumber,
          BigNumber,
          BigNumber,
          BigNumber,
          BigNumber,
          BigNumber
        ] & {
          indexer: string;
          subgraphDeploymentID: string;
          tokens: BigNumber;
          createdAtEpoch: BigNumber;
          closedAtEpoch: BigNumber;
          collectedFees: BigNumber;
          effectiveAllocation: BigNumber;
          accRewardsPerAllocatedToken: BigNumber;
        }
      ]
    >;

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

    getDelegation(
      _indexer: string,
      _delegator: string,
      overrides?: CallOverrides
    ): Promise<
      [
        [BigNumber, BigNumber, BigNumber] & {
          shares: BigNumber;
          tokensLocked: BigNumber;
          tokensLockedUntil: BigNumber;
        }
      ]
    >;

    getIndexerCapacity(
      _indexer: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

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

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

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

    isDelegator(
      _indexer: string,
      _delegator: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    isOperator(
      _operator: string,
      _indexer: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    setAssetHolder(
      _assetHolder: string,
      _allowed: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

    setDelegationParameters(
      _indexingRewardCut: BigNumberish,
      _queryFeeCut: BigNumberish,
      _cooldownBlocks: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

    setOperator(
      _operator: string,
      _allowed: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    setRebateRatio(
      _alphaNumerator: BigNumberish,
      _alphaDenominator: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    setSlasher(
      _slasher: string,
      _allowed: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    slash(
      _indexer: string,
      _tokens: BigNumberish,
      _reward: BigNumberish,
      _beneficiary: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    stakeTo(
      _indexer: string,
      _tokens: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    undelegate(
      _indexer: string,
      _shares: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

    withdrawDelegated(
      _indexer: string,
      _newIndexer: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;
  };

  allocate(
    _subgraphDeploymentID: BytesLike,
    _tokens: BigNumberish,
    _allocationID: string,
    _metadata: BytesLike,
    _proof: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  allocateFrom(
    _indexer: string,
    _subgraphDeploymentID: BytesLike,
    _tokens: BigNumberish,
    _allocationID: string,
    _metadata: BytesLike,
    _proof: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  claim(
    _allocationID: string,
    _restake: boolean,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  claimMany(
    _allocationID: string[],
    _restake: boolean,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  closeAllocation(
    _allocationID: string,
    _poi: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  closeAllocationMany(
    _requests: { allocationID: string; poi: BytesLike }[],
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  closeAndAllocate(
    _oldAllocationID: string,
    _poi: BytesLike,
    _indexer: string,
    _subgraphDeploymentID: BytesLike,
    _tokens: BigNumberish,
    _allocationID: string,
    _metadata: BytesLike,
    _proof: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  collect(
    _tokens: BigNumberish,
    _allocationID: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  getAllocation(
    _allocationID: string,
    overrides?: CallOverrides
  ): Promise<
    [
      string,
      string,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber
    ] & {
      indexer: string;
      subgraphDeploymentID: string;
      tokens: BigNumber;
      createdAtEpoch: BigNumber;
      closedAtEpoch: BigNumber;
      collectedFees: BigNumber;
      effectiveAllocation: BigNumber;
      accRewardsPerAllocatedToken: BigNumber;
    }
  >;

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

  getDelegation(
    _indexer: string,
    _delegator: string,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber, BigNumber] & {
      shares: BigNumber;
      tokensLocked: BigNumber;
      tokensLockedUntil: BigNumber;
    }
  >;

  getIndexerCapacity(
    _indexer: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

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

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

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

  isDelegator(
    _indexer: string,
    _delegator: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

  isOperator(
    _operator: string,
    _indexer: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

  setAssetHolder(
    _assetHolder: string,
    _allowed: boolean,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

  setDelegationParameters(
    _indexingRewardCut: BigNumberish,
    _queryFeeCut: BigNumberish,
    _cooldownBlocks: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

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

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

  setOperator(
    _operator: string,
    _allowed: boolean,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  setRebateRatio(
    _alphaNumerator: BigNumberish,
    _alphaDenominator: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  setSlasher(
    _slasher: string,
    _allowed: boolean,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  slash(
    _indexer: string,
    _tokens: BigNumberish,
    _reward: BigNumberish,
    _beneficiary: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  stakeTo(
    _indexer: string,
    _tokens: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  undelegate(
    _indexer: string,
    _shares: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

  withdrawDelegated(
    _indexer: string,
    _newIndexer: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  callStatic: {
    allocate(
      _subgraphDeploymentID: BytesLike,
      _tokens: BigNumberish,
      _allocationID: string,
      _metadata: BytesLike,
      _proof: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

    allocateFrom(
      _indexer: string,
      _subgraphDeploymentID: BytesLike,
      _tokens: BigNumberish,
      _allocationID: string,
      _metadata: BytesLike,
      _proof: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

    claim(
      _allocationID: string,
      _restake: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

    claimMany(
      _allocationID: string[],
      _restake: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

    closeAllocation(
      _allocationID: string,
      _poi: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

    closeAllocationMany(
      _requests: { allocationID: string; poi: BytesLike }[],
      overrides?: CallOverrides
    ): Promise<void>;

    closeAndAllocate(
      _oldAllocationID: string,
      _poi: BytesLike,
      _indexer: string,
      _subgraphDeploymentID: BytesLike,
      _tokens: BigNumberish,
      _allocationID: string,
      _metadata: BytesLike,
      _proof: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

    collect(
      _tokens: BigNumberish,
      _allocationID: string,
      overrides?: CallOverrides
    ): Promise<void>;

    delegate(
      _indexer: string,
      _tokens: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getAllocation(
      _allocationID: string,
      overrides?: CallOverrides
    ): Promise<
      [
        string,
        string,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber
      ] & {
        indexer: string;
        subgraphDeploymentID: string;
        tokens: BigNumber;
        createdAtEpoch: BigNumber;
        closedAtEpoch: BigNumber;
        collectedFees: BigNumber;
        effectiveAllocation: BigNumber;
        accRewardsPerAllocatedToken: BigNumber;
      }
    >;

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

    getDelegation(
      _indexer: string,
      _delegator: string,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber] & {
        shares: BigNumber;
        tokensLocked: BigNumber;
        tokensLockedUntil: BigNumber;
      }
    >;

    getIndexerCapacity(
      _indexer: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

    isDelegator(
      _indexer: string,
      _delegator: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

    isOperator(
      _operator: string,
      _indexer: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

    setAssetHolder(
      _assetHolder: string,
      _allowed: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

    setChannelDisputeEpochs(
      _channelDisputeEpochs: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setCurationPercentage(
      _percentage: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setDelegationParameters(
      _indexingRewardCut: BigNumberish,
      _queryFeeCut: BigNumberish,
      _cooldownBlocks: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setDelegationParametersCooldown(
      _blocks: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setDelegationRatio(
      _delegationRatio: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setDelegationTaxPercentage(
      _percentage: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setDelegationUnbondingPeriod(
      _delegationUnbondingPeriod: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setMaxAllocationEpochs(
      _maxAllocationEpochs: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setMinimumIndexerStake(
      _minimumIndexerStake: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setOperator(
      _operator: string,
      _allowed: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

    setProtocolPercentage(
      _percentage: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setRebateRatio(
      _alphaNumerator: BigNumberish,
      _alphaDenominator: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setRewardsDestination(
      _destination: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setSlasher(
      _slasher: string,
      _allowed: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

    setThawingPeriod(
      _thawingPeriod: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    slash(
      _indexer: string,
      _tokens: BigNumberish,
      _reward: BigNumberish,
      _beneficiary: string,
      overrides?: CallOverrides
    ): Promise<void>;

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

    stakeTo(
      _indexer: string,
      _tokens: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    undelegate(
      _indexer: string,
      _shares: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    withdrawDelegated(
      _indexer: string,
      _newIndexer: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;
  };

  filters: {};

  estimateGas: {
    allocate(
      _subgraphDeploymentID: BytesLike,
      _tokens: BigNumberish,
      _allocationID: string,
      _metadata: BytesLike,
      _proof: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    allocateFrom(
      _indexer: string,
      _subgraphDeploymentID: BytesLike,
      _tokens: BigNumberish,
      _allocationID: string,
      _metadata: BytesLike,
      _proof: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    claim(
      _allocationID: string,
      _restake: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    claimMany(
      _allocationID: string[],
      _restake: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    closeAllocation(
      _allocationID: string,
      _poi: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    closeAllocationMany(
      _requests: { allocationID: string; poi: BytesLike }[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    closeAndAllocate(
      _oldAllocationID: string,
      _poi: BytesLike,
      _indexer: string,
      _subgraphDeploymentID: BytesLike,
      _tokens: BigNumberish,
      _allocationID: string,
      _metadata: BytesLike,
      _proof: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    collect(
      _tokens: BigNumberish,
      _allocationID: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

    getDelegation(
      _indexer: string,
      _delegator: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getIndexerCapacity(
      _indexer: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

    isDelegator(
      _indexer: string,
      _delegator: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    isOperator(
      _operator: string,
      _indexer: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    setAssetHolder(
      _assetHolder: string,
      _allowed: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

    setDelegationParameters(
      _indexingRewardCut: BigNumberish,
      _queryFeeCut: BigNumberish,
      _cooldownBlocks: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

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

    setOperator(
      _operator: string,
      _allowed: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    setRebateRatio(
      _alphaNumerator: BigNumberish,
      _alphaDenominator: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    setSlasher(
      _slasher: string,
      _allowed: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    slash(
      _indexer: string,
      _tokens: BigNumberish,
      _reward: BigNumberish,
      _beneficiary: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    stakeTo(
      _indexer: string,
      _tokens: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    undelegate(
      _indexer: string,
      _shares: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

    withdrawDelegated(
      _indexer: string,
      _newIndexer: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;
  };

  populateTransaction: {
    allocate(
      _subgraphDeploymentID: BytesLike,
      _tokens: BigNumberish,
      _allocationID: string,
      _metadata: BytesLike,
      _proof: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    allocateFrom(
      _indexer: string,
      _subgraphDeploymentID: BytesLike,
      _tokens: BigNumberish,
      _allocationID: string,
      _metadata: BytesLike,
      _proof: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    claim(
      _allocationID: string,
      _restake: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    claimMany(
      _allocationID: string[],
      _restake: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    closeAllocation(
      _allocationID: string,
      _poi: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    closeAllocationMany(
      _requests: { allocationID: string; poi: BytesLike }[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    closeAndAllocate(
      _oldAllocationID: string,
      _poi: BytesLike,
      _indexer: string,
      _subgraphDeploymentID: BytesLike,
      _tokens: BigNumberish,
      _allocationID: string,
      _metadata: BytesLike,
      _proof: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    collect(
      _tokens: BigNumberish,
      _allocationID: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

    getDelegation(
      _indexer: string,
      _delegator: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getIndexerCapacity(
      _indexer: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

    isDelegator(
      _indexer: string,
      _delegator: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    isOperator(
      _operator: string,
      _indexer: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    setAssetHolder(
      _assetHolder: string,
      _allowed: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

    setDelegationParameters(
      _indexingRewardCut: BigNumberish,
      _queryFeeCut: BigNumberish,
      _cooldownBlocks: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

    setOperator(
      _operator: string,
      _allowed: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    setRebateRatio(
      _alphaNumerator: BigNumberish,
      _alphaDenominator: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    setSlasher(
      _slasher: string,
      _allowed: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    slash(
      _indexer: string,
      _tokens: BigNumberish,
      _reward: BigNumberish,
      _beneficiary: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    stakeTo(
      _indexer: string,
      _tokens: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    undelegate(
      _indexer: string,
      _shares: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

    withdrawDelegated(
      _indexer: string,
      _newIndexer: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;
  };
}
