/* 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 StakingInterface extends ethers.utils.Interface {
  functions: {
    "acceptProxy(address)": FunctionFragment;
    "acceptProxyAndCall(address,bytes)": FunctionFragment;
    "allocate(bytes32,uint256,address,bytes32,bytes)": FunctionFragment;
    "allocateFrom(address,bytes32,uint256,address,bytes32,bytes)": FunctionFragment;
    "allocations(address)": FunctionFragment;
    "alphaDenominator()": FunctionFragment;
    "alphaNumerator()": FunctionFragment;
    "assetHolders(address)": FunctionFragment;
    "channelDisputeEpochs()": 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;
    "controller()": FunctionFragment;
    "curationPercentage()": FunctionFragment;
    "delegate(address,uint256)": FunctionFragment;
    "delegationParametersCooldown()": FunctionFragment;
    "delegationPools(address)": FunctionFragment;
    "delegationRatio()": FunctionFragment;
    "delegationTaxPercentage()": FunctionFragment;
    "delegationUnbondingPeriod()": FunctionFragment;
    "getAllocation(address)": FunctionFragment;
    "getAllocationState(address)": FunctionFragment;
    "getDelegation(address,address)": FunctionFragment;
    "getIndexerCapacity(address)": FunctionFragment;
    "getIndexerStakedTokens(address)": FunctionFragment;
    "getSubgraphAllocatedTokens(bytes32)": FunctionFragment;
    "getWithdraweableDelegatedTokens(tuple)": FunctionFragment;
    "hasStake(address)": FunctionFragment;
    "initialize(address,uint256,uint32,uint32,uint32,uint32,uint32,uint32,uint32,uint32,uint32)": FunctionFragment;
    "isAllocation(address)": FunctionFragment;
    "isDelegator(address,address)": FunctionFragment;
    "isOperator(address,address)": FunctionFragment;
    "maxAllocationEpochs()": FunctionFragment;
    "minimumIndexerStake()": FunctionFragment;
    "operatorAuth(address,address)": FunctionFragment;
    "protocolPercentage()": FunctionFragment;
    "rebates(uint256)": FunctionFragment;
    "rewardsDestination(address)": FunctionFragment;
    "setAssetHolder(address,bool)": FunctionFragment;
    "setChannelDisputeEpochs(uint32)": FunctionFragment;
    "setController(address)": 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;
    "slashers(address)": FunctionFragment;
    "stake(uint256)": FunctionFragment;
    "stakeTo(address,uint256)": FunctionFragment;
    "stakes(address)": FunctionFragment;
    "subgraphAllocations(bytes32)": FunctionFragment;
    "syncAllContracts()": FunctionFragment;
    "thawingPeriod()": FunctionFragment;
    "undelegate(address,uint256)": FunctionFragment;
    "unstake(uint256)": FunctionFragment;
    "withdraw()": FunctionFragment;
    "withdrawDelegated(address,address)": FunctionFragment;
  };

  encodeFunctionData(functionFragment: "acceptProxy", values: [string]): string;
  encodeFunctionData(
    functionFragment: "acceptProxyAndCall",
    values: [string, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "allocate",
    values: [BytesLike, BigNumberish, string, BytesLike, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "allocateFrom",
    values: [string, BytesLike, BigNumberish, string, BytesLike, BytesLike]
  ): string;
  encodeFunctionData(functionFragment: "allocations", values: [string]): string;
  encodeFunctionData(
    functionFragment: "alphaDenominator",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "alphaNumerator",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "assetHolders",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "channelDisputeEpochs",
    values?: undefined
  ): 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: "controller",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "curationPercentage",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "delegate",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "delegationParametersCooldown",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "delegationPools",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "delegationRatio",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "delegationTaxPercentage",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "delegationUnbondingPeriod",
    values?: undefined
  ): 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: "getWithdraweableDelegatedTokens",
    values: [
      {
        shares: BigNumberish;
        tokensLocked: BigNumberish;
        tokensLockedUntil: BigNumberish;
      }
    ]
  ): string;
  encodeFunctionData(functionFragment: "hasStake", values: [string]): string;
  encodeFunctionData(
    functionFragment: "initialize",
    values: [
      string,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "isAllocation",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "isDelegator",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "isOperator",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "maxAllocationEpochs",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "minimumIndexerStake",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "operatorAuth",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "protocolPercentage",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "rebates",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "rewardsDestination",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setAssetHolder",
    values: [string, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "setChannelDisputeEpochs",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setController",
    values: [string]
  ): 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: "slashers", values: [string]): string;
  encodeFunctionData(functionFragment: "stake", values: [BigNumberish]): string;
  encodeFunctionData(
    functionFragment: "stakeTo",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "stakes", values: [string]): string;
  encodeFunctionData(
    functionFragment: "subgraphAllocations",
    values: [BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "syncAllContracts",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "thawingPeriod",
    values?: undefined
  ): 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: "acceptProxy",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "acceptProxyAndCall",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "allocate", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "allocateFrom",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "allocations",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "alphaDenominator",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "alphaNumerator",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "assetHolders",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "channelDisputeEpochs",
    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: "controller", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "curationPercentage",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "delegate", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "delegationParametersCooldown",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "delegationPools",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "delegationRatio",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "delegationTaxPercentage",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "delegationUnbondingPeriod",
    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: "getWithdraweableDelegatedTokens",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "hasStake", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "isAllocation",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isDelegator",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "isOperator", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "maxAllocationEpochs",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "minimumIndexerStake",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "operatorAuth",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "protocolPercentage",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "rebates", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "rewardsDestination",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setAssetHolder",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setChannelDisputeEpochs",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setController",
    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: "slashers", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "stake", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "stakeTo", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "stakes", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "subgraphAllocations",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "syncAllContracts",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "thawingPeriod",
    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: {
    "AllocationClosed(address,bytes32,uint256,uint256,address,uint256,address,bytes32,bool)": EventFragment;
    "AllocationCollected(address,bytes32,uint256,uint256,address,address,uint256,uint256)": EventFragment;
    "AllocationCreated(address,bytes32,uint256,uint256,address,bytes32)": EventFragment;
    "AssetHolderUpdate(address,address,bool)": EventFragment;
    "ContractSynced(bytes32,address)": EventFragment;
    "DelegationParametersUpdated(address,uint32,uint32,uint32)": EventFragment;
    "ParameterUpdated(string)": EventFragment;
    "RebateClaimed(address,bytes32,address,uint256,uint256,uint256,uint256,uint256)": EventFragment;
    "SetController(address)": EventFragment;
    "SetOperator(address,address,bool)": EventFragment;
    "SetRewardsDestination(address,address)": EventFragment;
    "SlasherUpdate(address,address,bool)": EventFragment;
    "StakeDelegated(address,address,uint256,uint256)": EventFragment;
    "StakeDelegatedLocked(address,address,uint256,uint256,uint256)": EventFragment;
    "StakeDelegatedWithdrawn(address,address,uint256)": EventFragment;
    "StakeDeposited(address,uint256)": EventFragment;
    "StakeLocked(address,uint256,uint256)": EventFragment;
    "StakeSlashed(address,uint256,uint256,address)": EventFragment;
    "StakeWithdrawn(address,uint256)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "AllocationClosed"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "AllocationCollected"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "AllocationCreated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "AssetHolderUpdate"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ContractSynced"): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "DelegationParametersUpdated"
  ): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ParameterUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RebateClaimed"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SetController"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SetOperator"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SetRewardsDestination"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SlasherUpdate"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "StakeDelegated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "StakeDelegatedLocked"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "StakeDelegatedWithdrawn"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "StakeDeposited"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "StakeLocked"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "StakeSlashed"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "StakeWithdrawn"): EventFragment;
}

export class Staking 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: StakingInterface;

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

    acceptProxyAndCall(
      _proxy: string,
      _data: BytesLike,
      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>;

    allocations(
      arg0: 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;
      }
    >;

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

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

    assetHolders(arg0: string, overrides?: CallOverrides): Promise<[boolean]>;

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

    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(
      _closingAllocationID: 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>;

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

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

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

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

    delegationPools(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<
      [number, number, number, BigNumber, BigNumber, BigNumber] & {
        cooldownBlocks: number;
        indexingRewardCut: number;
        queryFeeCut: number;
        updatedAtBlock: BigNumber;
        tokens: BigNumber;
        shares: BigNumber;
      }
    >;

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

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

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

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

    getWithdraweableDelegatedTokens(
      _delegation: {
        shares: BigNumberish;
        tokensLocked: BigNumberish;
        tokensLockedUntil: BigNumberish;
      },
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

    initialize(
      _controller: string,
      _minimumIndexerStake: BigNumberish,
      _thawingPeriod: BigNumberish,
      _protocolPercentage: BigNumberish,
      _curationPercentage: BigNumberish,
      _channelDisputeEpochs: BigNumberish,
      _maxAllocationEpochs: BigNumberish,
      _delegationUnbondingPeriod: BigNumberish,
      _delegationRatio: BigNumberish,
      _rebateAlphaNumerator: BigNumberish,
      _rebateAlphaDenominator: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

    operatorAuth(
      arg0: string,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

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

    rebates(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber, number, number, number] & {
        fees: BigNumber;
        effectiveAllocatedStake: BigNumber;
        claimedRewards: BigNumber;
        unclaimedAllocationsCount: number;
        alphaNumerator: number;
        alphaDenominator: number;
      }
    >;

    rewardsDestination(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<[string]>;

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

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

    setController(
      _controller: string,
      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>;

    slashers(arg0: string, overrides?: CallOverrides): Promise<[boolean]>;

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

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

    stakes(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber, BigNumber] & {
        tokensStaked: BigNumber;
        tokensAllocated: BigNumber;
        tokensLocked: BigNumber;
        tokensLockedUntil: BigNumber;
      }
    >;

    subgraphAllocations(
      arg0: BytesLike,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

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

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

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

  acceptProxyAndCall(
    _proxy: string,
    _data: BytesLike,
    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>;

  allocations(
    arg0: 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;
    }
  >;

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

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

  assetHolders(arg0: string, overrides?: CallOverrides): Promise<boolean>;

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

  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(
    _closingAllocationID: 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>;

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

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

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

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

  delegationPools(
    arg0: string,
    overrides?: CallOverrides
  ): Promise<
    [number, number, number, BigNumber, BigNumber, BigNumber] & {
      cooldownBlocks: number;
      indexingRewardCut: number;
      queryFeeCut: number;
      updatedAtBlock: BigNumber;
      tokens: BigNumber;
      shares: BigNumber;
    }
  >;

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

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

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

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

  getWithdraweableDelegatedTokens(
    _delegation: {
      shares: BigNumberish;
      tokensLocked: BigNumberish;
      tokensLockedUntil: BigNumberish;
    },
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

  initialize(
    _controller: string,
    _minimumIndexerStake: BigNumberish,
    _thawingPeriod: BigNumberish,
    _protocolPercentage: BigNumberish,
    _curationPercentage: BigNumberish,
    _channelDisputeEpochs: BigNumberish,
    _maxAllocationEpochs: BigNumberish,
    _delegationUnbondingPeriod: BigNumberish,
    _delegationRatio: BigNumberish,
    _rebateAlphaNumerator: BigNumberish,
    _rebateAlphaDenominator: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

  operatorAuth(
    arg0: string,
    arg1: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

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

  rebates(
    arg0: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber, BigNumber, number, number, number] & {
      fees: BigNumber;
      effectiveAllocatedStake: BigNumber;
      claimedRewards: BigNumber;
      unclaimedAllocationsCount: number;
      alphaNumerator: number;
      alphaDenominator: number;
    }
  >;

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

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

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

  setController(
    _controller: string,
    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>;

  slashers(arg0: string, overrides?: CallOverrides): Promise<boolean>;

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

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

  stakes(
    arg0: string,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber, BigNumber, BigNumber] & {
      tokensStaked: BigNumber;
      tokensAllocated: BigNumber;
      tokensLocked: BigNumber;
      tokensLockedUntil: BigNumber;
    }
  >;

  subgraphAllocations(
    arg0: BytesLike,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

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

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

  callStatic: {
    acceptProxy(_proxy: string, overrides?: CallOverrides): Promise<void>;

    acceptProxyAndCall(
      _proxy: string,
      _data: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

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

    allocations(
      arg0: 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;
      }
    >;

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

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

    assetHolders(arg0: string, overrides?: CallOverrides): Promise<boolean>;

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

    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(
      _closingAllocationID: 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>;

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

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

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

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

    delegationPools(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<
      [number, number, number, BigNumber, BigNumber, BigNumber] & {
        cooldownBlocks: number;
        indexingRewardCut: number;
        queryFeeCut: number;
        updatedAtBlock: BigNumber;
        tokens: BigNumber;
        shares: BigNumber;
      }
    >;

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

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

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

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

    getWithdraweableDelegatedTokens(
      _delegation: {
        shares: BigNumberish;
        tokensLocked: BigNumberish;
        tokensLockedUntil: BigNumberish;
      },
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    initialize(
      _controller: string,
      _minimumIndexerStake: BigNumberish,
      _thawingPeriod: BigNumberish,
      _protocolPercentage: BigNumberish,
      _curationPercentage: BigNumberish,
      _channelDisputeEpochs: BigNumberish,
      _maxAllocationEpochs: BigNumberish,
      _delegationUnbondingPeriod: BigNumberish,
      _delegationRatio: BigNumberish,
      _rebateAlphaNumerator: BigNumberish,
      _rebateAlphaDenominator: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

    operatorAuth(
      arg0: string,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

    rebates(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber, number, number, number] & {
        fees: BigNumber;
        effectiveAllocatedStake: BigNumber;
        claimedRewards: BigNumber;
        unclaimedAllocationsCount: number;
        alphaNumerator: number;
        alphaDenominator: number;
      }
    >;

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

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

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

    setController(
      _controller: string,
      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>;

    slashers(arg0: string, overrides?: CallOverrides): Promise<boolean>;

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

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

    stakes(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber, BigNumber] & {
        tokensStaked: BigNumber;
        tokensAllocated: BigNumber;
        tokensLocked: BigNumber;
        tokensLockedUntil: BigNumber;
      }
    >;

    subgraphAllocations(
      arg0: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

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

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

  filters: {
    AllocationClosed(
      indexer?: string | null,
      subgraphDeploymentID?: BytesLike | null,
      epoch?: null,
      tokens?: null,
      allocationID?: string | null,
      effectiveAllocation?: null,
      sender?: null,
      poi?: null,
      isDelegator?: null
    ): TypedEventFilter<
      [
        string,
        string,
        BigNumber,
        BigNumber,
        string,
        BigNumber,
        string,
        string,
        boolean
      ],
      {
        indexer: string;
        subgraphDeploymentID: string;
        epoch: BigNumber;
        tokens: BigNumber;
        allocationID: string;
        effectiveAllocation: BigNumber;
        sender: string;
        poi: string;
        isDelegator: boolean;
      }
    >;

    AllocationCollected(
      indexer?: string | null,
      subgraphDeploymentID?: BytesLike | null,
      epoch?: null,
      tokens?: null,
      allocationID?: string | null,
      from?: null,
      curationFees?: null,
      rebateFees?: null
    ): TypedEventFilter<
      [
        string,
        string,
        BigNumber,
        BigNumber,
        string,
        string,
        BigNumber,
        BigNumber
      ],
      {
        indexer: string;
        subgraphDeploymentID: string;
        epoch: BigNumber;
        tokens: BigNumber;
        allocationID: string;
        from: string;
        curationFees: BigNumber;
        rebateFees: BigNumber;
      }
    >;

    AllocationCreated(
      indexer?: string | null,
      subgraphDeploymentID?: BytesLike | null,
      epoch?: null,
      tokens?: null,
      allocationID?: string | null,
      metadata?: null
    ): TypedEventFilter<
      [string, string, BigNumber, BigNumber, string, string],
      {
        indexer: string;
        subgraphDeploymentID: string;
        epoch: BigNumber;
        tokens: BigNumber;
        allocationID: string;
        metadata: string;
      }
    >;

    AssetHolderUpdate(
      caller?: string | null,
      assetHolder?: string | null,
      allowed?: null
    ): TypedEventFilter<
      [string, string, boolean],
      { caller: string; assetHolder: string; allowed: boolean }
    >;

    ContractSynced(
      nameHash?: BytesLike | null,
      contractAddress?: null
    ): TypedEventFilter<
      [string, string],
      { nameHash: string; contractAddress: string }
    >;

    DelegationParametersUpdated(
      indexer?: string | null,
      indexingRewardCut?: null,
      queryFeeCut?: null,
      cooldownBlocks?: null
    ): TypedEventFilter<
      [string, number, number, number],
      {
        indexer: string;
        indexingRewardCut: number;
        queryFeeCut: number;
        cooldownBlocks: number;
      }
    >;

    ParameterUpdated(
      param?: null
    ): TypedEventFilter<[string], { param: string }>;

    RebateClaimed(
      indexer?: string | null,
      subgraphDeploymentID?: BytesLike | null,
      allocationID?: string | null,
      epoch?: null,
      forEpoch?: null,
      tokens?: null,
      unclaimedAllocationsCount?: null,
      delegationFees?: null
    ): TypedEventFilter<
      [
        string,
        string,
        string,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber
      ],
      {
        indexer: string;
        subgraphDeploymentID: string;
        allocationID: string;
        epoch: BigNumber;
        forEpoch: BigNumber;
        tokens: BigNumber;
        unclaimedAllocationsCount: BigNumber;
        delegationFees: BigNumber;
      }
    >;

    SetController(
      controller?: null
    ): TypedEventFilter<[string], { controller: string }>;

    SetOperator(
      indexer?: string | null,
      operator?: string | null,
      allowed?: null
    ): TypedEventFilter<
      [string, string, boolean],
      { indexer: string; operator: string; allowed: boolean }
    >;

    SetRewardsDestination(
      indexer?: string | null,
      destination?: string | null
    ): TypedEventFilter<
      [string, string],
      { indexer: string; destination: string }
    >;

    SlasherUpdate(
      caller?: string | null,
      slasher?: string | null,
      allowed?: null
    ): TypedEventFilter<
      [string, string, boolean],
      { caller: string; slasher: string; allowed: boolean }
    >;

    StakeDelegated(
      indexer?: string | null,
      delegator?: string | null,
      tokens?: null,
      shares?: null
    ): TypedEventFilter<
      [string, string, BigNumber, BigNumber],
      {
        indexer: string;
        delegator: string;
        tokens: BigNumber;
        shares: BigNumber;
      }
    >;

    StakeDelegatedLocked(
      indexer?: string | null,
      delegator?: string | null,
      tokens?: null,
      shares?: null,
      until?: null
    ): TypedEventFilter<
      [string, string, BigNumber, BigNumber, BigNumber],
      {
        indexer: string;
        delegator: string;
        tokens: BigNumber;
        shares: BigNumber;
        until: BigNumber;
      }
    >;

    StakeDelegatedWithdrawn(
      indexer?: string | null,
      delegator?: string | null,
      tokens?: null
    ): TypedEventFilter<
      [string, string, BigNumber],
      { indexer: string; delegator: string; tokens: BigNumber }
    >;

    StakeDeposited(
      indexer?: string | null,
      tokens?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { indexer: string; tokens: BigNumber }
    >;

    StakeLocked(
      indexer?: string | null,
      tokens?: null,
      until?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber],
      { indexer: string; tokens: BigNumber; until: BigNumber }
    >;

    StakeSlashed(
      indexer?: string | null,
      tokens?: null,
      reward?: null,
      beneficiary?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber, string],
      {
        indexer: string;
        tokens: BigNumber;
        reward: BigNumber;
        beneficiary: string;
      }
    >;

    StakeWithdrawn(
      indexer?: string | null,
      tokens?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { indexer: string; tokens: BigNumber }
    >;
  };

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

    acceptProxyAndCall(
      _proxy: string,
      _data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    allocations(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;

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

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

    assetHolders(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;

    channelDisputeEpochs(overrides?: CallOverrides): 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(
      _closingAllocationID: 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>;

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

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

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

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

    delegationPools(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    delegationUnbondingPeriod(overrides?: CallOverrides): 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>;

    getWithdraweableDelegatedTokens(
      _delegation: {
        shares: BigNumberish;
        tokensLocked: BigNumberish;
        tokensLockedUntil: BigNumberish;
      },
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    initialize(
      _controller: string,
      _minimumIndexerStake: BigNumberish,
      _thawingPeriod: BigNumberish,
      _protocolPercentage: BigNumberish,
      _curationPercentage: BigNumberish,
      _channelDisputeEpochs: BigNumberish,
      _maxAllocationEpochs: BigNumberish,
      _delegationUnbondingPeriod: BigNumberish,
      _delegationRatio: BigNumberish,
      _rebateAlphaNumerator: BigNumberish,
      _rebateAlphaDenominator: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): 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>;

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

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

    operatorAuth(
      arg0: string,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    rebates(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;

    rewardsDestination(
      arg0: 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>;

    setController(
      _controller: string,
      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>;

    slashers(arg0: string, overrides?: CallOverrides): 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>;

    stakes(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;

    subgraphAllocations(
      arg0: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    thawingPeriod(overrides?: CallOverrides): 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,
      _delegateToIndexer: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;
  };

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

    acceptProxyAndCall(
      _proxy: string,
      _data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    allocations(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    assetHolders(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    channelDisputeEpochs(
      overrides?: CallOverrides
    ): 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(
      _closingAllocationID: 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>;

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

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

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

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

    delegationPools(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    delegationUnbondingPeriod(
      overrides?: CallOverrides
    ): 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>;

    getWithdraweableDelegatedTokens(
      _delegation: {
        shares: BigNumberish;
        tokensLocked: BigNumberish;
        tokensLockedUntil: BigNumberish;
      },
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    initialize(
      _controller: string,
      _minimumIndexerStake: BigNumberish,
      _thawingPeriod: BigNumberish,
      _protocolPercentage: BigNumberish,
      _curationPercentage: BigNumberish,
      _channelDisputeEpochs: BigNumberish,
      _maxAllocationEpochs: BigNumberish,
      _delegationUnbondingPeriod: BigNumberish,
      _delegationRatio: BigNumberish,
      _rebateAlphaNumerator: BigNumberish,
      _rebateAlphaDenominator: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): 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>;

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

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

    operatorAuth(
      arg0: string,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    rebates(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    rewardsDestination(
      arg0: 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>;

    setController(
      _controller: string,
      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>;

    slashers(
      arg0: string,
      overrides?: CallOverrides
    ): 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>;

    stakes(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    subgraphAllocations(
      arg0: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    thawingPeriod(overrides?: CallOverrides): 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,
      _delegateToIndexer: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;
  };
}
