import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PopulatedTransaction, Signer, utils } from "ethers";
import type { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
import type { Listener, Provider } from "@ethersproject/providers";
import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent, PromiseOrValue } from "../../../common";
export declare namespace IStakingData {
    type AllocationStruct = {
        indexer: PromiseOrValue<string>;
        subgraphDeploymentID: PromiseOrValue<BytesLike>;
        tokens: PromiseOrValue<BigNumberish>;
        createdAtEpoch: PromiseOrValue<BigNumberish>;
        closedAtEpoch: PromiseOrValue<BigNumberish>;
        collectedFees: PromiseOrValue<BigNumberish>;
        __DEPRECATED_effectiveAllocation: PromiseOrValue<BigNumberish>;
        accRewardsPerAllocatedToken: PromiseOrValue<BigNumberish>;
        distributedRebates: PromiseOrValue<BigNumberish>;
    };
    type AllocationStructOutput = [
        string,
        string,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber
    ] & {
        indexer: string;
        subgraphDeploymentID: string;
        tokens: BigNumber;
        createdAtEpoch: BigNumber;
        closedAtEpoch: BigNumber;
        collectedFees: BigNumber;
        __DEPRECATED_effectiveAllocation: BigNumber;
        accRewardsPerAllocatedToken: BigNumber;
        distributedRebates: BigNumber;
    };
    type DelegationStruct = {
        shares: PromiseOrValue<BigNumberish>;
        tokensLocked: PromiseOrValue<BigNumberish>;
        tokensLockedUntil: PromiseOrValue<BigNumberish>;
    };
    type DelegationStructOutput = [BigNumber, BigNumber, BigNumber] & {
        shares: BigNumber;
        tokensLocked: BigNumber;
        tokensLockedUntil: BigNumber;
    };
    type RebatesParametersStruct = {
        alphaNumerator: PromiseOrValue<BigNumberish>;
        alphaDenominator: PromiseOrValue<BigNumberish>;
        lambdaNumerator: PromiseOrValue<BigNumberish>;
        lambdaDenominator: PromiseOrValue<BigNumberish>;
    };
    type RebatesParametersStructOutput = [
        number,
        number,
        number,
        number
    ] & {
        alphaNumerator: number;
        alphaDenominator: number;
        lambdaNumerator: number;
        lambdaDenominator: number;
    };
}
export declare namespace IStakingExtension {
    type DelegationPoolReturnStruct = {
        __DEPRECATED_cooldownBlocks: PromiseOrValue<BigNumberish>;
        indexingRewardCut: PromiseOrValue<BigNumberish>;
        queryFeeCut: PromiseOrValue<BigNumberish>;
        updatedAtBlock: PromiseOrValue<BigNumberish>;
        tokens: PromiseOrValue<BigNumberish>;
        shares: PromiseOrValue<BigNumberish>;
    };
    type DelegationPoolReturnStructOutput = [
        number,
        number,
        number,
        BigNumber,
        BigNumber,
        BigNumber
    ] & {
        __DEPRECATED_cooldownBlocks: number;
        indexingRewardCut: number;
        queryFeeCut: number;
        updatedAtBlock: BigNumber;
        tokens: BigNumber;
        shares: BigNumber;
    };
}
export declare namespace IStakes {
    type IndexerStruct = {
        tokensStaked: PromiseOrValue<BigNumberish>;
        tokensAllocated: PromiseOrValue<BigNumberish>;
        tokensLocked: PromiseOrValue<BigNumberish>;
        tokensLockedUntil: PromiseOrValue<BigNumberish>;
    };
    type IndexerStructOutput = [
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber
    ] & {
        tokensStaked: BigNumber;
        tokensAllocated: BigNumber;
        tokensLocked: BigNumber;
        tokensLockedUntil: BigNumber;
    };
}
export interface IStakingInterface extends utils.Interface {
    functions: {
        "allocate(bytes32,uint256,address,bytes32,bytes)": FunctionFragment;
        "allocateFrom(address,bytes32,uint256,address,bytes32,bytes)": FunctionFragment;
        "allocations(address)": FunctionFragment;
        "alphaDenominator()": FunctionFragment;
        "alphaNumerator()": FunctionFragment;
        "closeAllocation(address,bytes32)": FunctionFragment;
        "collect(uint256,address)": FunctionFragment;
        "controller()": FunctionFragment;
        "curationPercentage()": FunctionFragment;
        "delegate(address,uint256)": FunctionFragment;
        "delegationPools(address)": FunctionFragment;
        "delegationRatio()": FunctionFragment;
        "delegationTaxPercentage()": FunctionFragment;
        "delegationUnbondingPeriod()": FunctionFragment;
        "getAllocation(address)": FunctionFragment;
        "getAllocationData(address)": FunctionFragment;
        "getAllocationState(address)": FunctionFragment;
        "getDelegation(address,address)": FunctionFragment;
        "getIndexerCapacity(address)": FunctionFragment;
        "getIndexerStakedTokens(address)": FunctionFragment;
        "getSubgraphAllocatedTokens(bytes32)": FunctionFragment;
        "getWithdraweableDelegatedTokens((uint256,uint256,uint256))": FunctionFragment;
        "hasStake(address)": FunctionFragment;
        "initialize(address,uint256,uint32,uint32,uint32,uint32,uint32,uint32,(uint32,uint32,uint32,uint32),address)": FunctionFragment;
        "isActiveAllocation(address)": FunctionFragment;
        "isAllocation(address)": FunctionFragment;
        "isDelegator(address,address)": FunctionFragment;
        "isOperator(address,address)": FunctionFragment;
        "lambdaDenominator()": FunctionFragment;
        "lambdaNumerator()": FunctionFragment;
        "maxAllocationEpochs()": FunctionFragment;
        "minimumIndexerStake()": FunctionFragment;
        "multicall(bytes[])": FunctionFragment;
        "operatorAuth(address,address)": FunctionFragment;
        "protocolPercentage()": FunctionFragment;
        "rewardsDestination(address)": FunctionFragment;
        "setController(address)": FunctionFragment;
        "setCounterpartStakingAddress(address)": FunctionFragment;
        "setCurationPercentage(uint32)": FunctionFragment;
        "setDelegationParameters(uint32,uint32,uint32)": FunctionFragment;
        "setDelegationRatio(uint32)": FunctionFragment;
        "setDelegationTaxPercentage(uint32)": FunctionFragment;
        "setDelegationUnbondingPeriod(uint32)": FunctionFragment;
        "setExtensionImpl(address)": FunctionFragment;
        "setMaxAllocationEpochs(uint32)": FunctionFragment;
        "setMinimumIndexerStake(uint256)": FunctionFragment;
        "setOperator(address,bool)": FunctionFragment;
        "setProtocolPercentage(uint32)": FunctionFragment;
        "setRebateParameters(uint32,uint32,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;
    };
    getFunction(nameOrSignatureOrTopic: "allocate" | "allocateFrom" | "allocations" | "alphaDenominator" | "alphaNumerator" | "closeAllocation" | "collect" | "controller" | "curationPercentage" | "delegate" | "delegationPools" | "delegationRatio" | "delegationTaxPercentage" | "delegationUnbondingPeriod" | "getAllocation" | "getAllocationData" | "getAllocationState" | "getDelegation" | "getIndexerCapacity" | "getIndexerStakedTokens" | "getSubgraphAllocatedTokens" | "getWithdraweableDelegatedTokens" | "hasStake" | "initialize" | "isActiveAllocation" | "isAllocation" | "isDelegator" | "isOperator" | "lambdaDenominator" | "lambdaNumerator" | "maxAllocationEpochs" | "minimumIndexerStake" | "multicall" | "operatorAuth" | "protocolPercentage" | "rewardsDestination" | "setController" | "setCounterpartStakingAddress" | "setCurationPercentage" | "setDelegationParameters" | "setDelegationRatio" | "setDelegationTaxPercentage" | "setDelegationUnbondingPeriod" | "setExtensionImpl" | "setMaxAllocationEpochs" | "setMinimumIndexerStake" | "setOperator" | "setProtocolPercentage" | "setRebateParameters" | "setRewardsDestination" | "setSlasher" | "setThawingPeriod" | "slash" | "slashers" | "stake" | "stakeTo" | "stakes" | "subgraphAllocations" | "syncAllContracts" | "thawingPeriod" | "undelegate" | "unstake" | "withdraw" | "withdrawDelegated"): FunctionFragment;
    encodeFunctionData(functionFragment: "allocate", values: [
        PromiseOrValue<BytesLike>,
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<string>,
        PromiseOrValue<BytesLike>,
        PromiseOrValue<BytesLike>
    ]): string;
    encodeFunctionData(functionFragment: "allocateFrom", values: [
        PromiseOrValue<string>,
        PromiseOrValue<BytesLike>,
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<string>,
        PromiseOrValue<BytesLike>,
        PromiseOrValue<BytesLike>
    ]): string;
    encodeFunctionData(functionFragment: "allocations", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "alphaDenominator", values?: undefined): string;
    encodeFunctionData(functionFragment: "alphaNumerator", values?: undefined): string;
    encodeFunctionData(functionFragment: "closeAllocation", values: [PromiseOrValue<string>, PromiseOrValue<BytesLike>]): string;
    encodeFunctionData(functionFragment: "collect", values: [PromiseOrValue<BigNumberish>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "controller", values?: undefined): string;
    encodeFunctionData(functionFragment: "curationPercentage", values?: undefined): string;
    encodeFunctionData(functionFragment: "delegate", values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "delegationPools", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "delegationRatio", values?: undefined): string;
    encodeFunctionData(functionFragment: "delegationTaxPercentage", values?: undefined): string;
    encodeFunctionData(functionFragment: "delegationUnbondingPeriod", values?: undefined): string;
    encodeFunctionData(functionFragment: "getAllocation", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "getAllocationData", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "getAllocationState", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "getDelegation", values: [PromiseOrValue<string>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "getIndexerCapacity", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "getIndexerStakedTokens", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "getSubgraphAllocatedTokens", values: [PromiseOrValue<BytesLike>]): string;
    encodeFunctionData(functionFragment: "getWithdraweableDelegatedTokens", values: [IStakingData.DelegationStruct]): string;
    encodeFunctionData(functionFragment: "hasStake", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "initialize", values: [
        PromiseOrValue<string>,
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<BigNumberish>,
        IStakingData.RebatesParametersStruct,
        PromiseOrValue<string>
    ]): string;
    encodeFunctionData(functionFragment: "isActiveAllocation", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "isAllocation", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "isDelegator", values: [PromiseOrValue<string>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "isOperator", values: [PromiseOrValue<string>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "lambdaDenominator", values?: undefined): string;
    encodeFunctionData(functionFragment: "lambdaNumerator", values?: undefined): string;
    encodeFunctionData(functionFragment: "maxAllocationEpochs", values?: undefined): string;
    encodeFunctionData(functionFragment: "minimumIndexerStake", values?: undefined): string;
    encodeFunctionData(functionFragment: "multicall", values: [PromiseOrValue<BytesLike>[]]): string;
    encodeFunctionData(functionFragment: "operatorAuth", values: [PromiseOrValue<string>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "protocolPercentage", values?: undefined): string;
    encodeFunctionData(functionFragment: "rewardsDestination", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "setController", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "setCounterpartStakingAddress", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "setCurationPercentage", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "setDelegationParameters", values: [
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<BigNumberish>
    ]): string;
    encodeFunctionData(functionFragment: "setDelegationRatio", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "setDelegationTaxPercentage", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "setDelegationUnbondingPeriod", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "setExtensionImpl", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "setMaxAllocationEpochs", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "setMinimumIndexerStake", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "setOperator", values: [PromiseOrValue<string>, PromiseOrValue<boolean>]): string;
    encodeFunctionData(functionFragment: "setProtocolPercentage", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "setRebateParameters", values: [
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<BigNumberish>
    ]): string;
    encodeFunctionData(functionFragment: "setRewardsDestination", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "setSlasher", values: [PromiseOrValue<string>, PromiseOrValue<boolean>]): string;
    encodeFunctionData(functionFragment: "setThawingPeriod", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "slash", values: [
        PromiseOrValue<string>,
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<string>
    ]): string;
    encodeFunctionData(functionFragment: "slashers", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "stake", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "stakeTo", values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "stakes", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "subgraphAllocations", values: [PromiseOrValue<BytesLike>]): string;
    encodeFunctionData(functionFragment: "syncAllContracts", values?: undefined): string;
    encodeFunctionData(functionFragment: "thawingPeriod", values?: undefined): string;
    encodeFunctionData(functionFragment: "undelegate", values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "unstake", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "withdraw", values?: undefined): string;
    encodeFunctionData(functionFragment: "withdrawDelegated", values: [PromiseOrValue<string>, PromiseOrValue<string>]): string;
    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: "closeAllocation", 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: "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: "getAllocationData", 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: "isActiveAllocation", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "isAllocation", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "isDelegator", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "isOperator", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "lambdaDenominator", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "lambdaNumerator", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "maxAllocationEpochs", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "minimumIndexerStake", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "multicall", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "operatorAuth", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "protocolPercentage", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "rewardsDestination", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setController", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setCounterpartStakingAddress", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setCurationPercentage", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setDelegationParameters", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setDelegationRatio", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setDelegationTaxPercentage", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setDelegationUnbondingPeriod", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setExtensionImpl", 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: "setRebateParameters", 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,address,bytes32,bool)": EventFragment;
        "AllocationCreated(address,bytes32,uint256,uint256,address,bytes32)": EventFragment;
        "DelegationParametersUpdated(address,uint32,uint32,uint32)": EventFragment;
        "ExtensionImplementationSet(address)": EventFragment;
        "RebateCollected(address,address,bytes32,address,uint256,uint256,uint256,uint256,uint256,uint256,uint256)": 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: "AllocationCreated"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "DelegationParametersUpdated"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "ExtensionImplementationSet"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "RebateCollected"): 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 interface AllocationClosedEventObject {
    indexer: string;
    subgraphDeploymentID: string;
    epoch: BigNumber;
    tokens: BigNumber;
    allocationID: string;
    sender: string;
    poi: string;
    isPublic: boolean;
}
export type AllocationClosedEvent = TypedEvent<[
    string,
    string,
    BigNumber,
    BigNumber,
    string,
    string,
    string,
    boolean
], AllocationClosedEventObject>;
export type AllocationClosedEventFilter = TypedEventFilter<AllocationClosedEvent>;
export interface AllocationCreatedEventObject {
    indexer: string;
    subgraphDeploymentID: string;
    epoch: BigNumber;
    tokens: BigNumber;
    allocationID: string;
    metadata: string;
}
export type AllocationCreatedEvent = TypedEvent<[
    string,
    string,
    BigNumber,
    BigNumber,
    string,
    string
], AllocationCreatedEventObject>;
export type AllocationCreatedEventFilter = TypedEventFilter<AllocationCreatedEvent>;
export interface DelegationParametersUpdatedEventObject {
    indexer: string;
    indexingRewardCut: number;
    queryFeeCut: number;
    __DEPRECATED_cooldownBlocks: number;
}
export type DelegationParametersUpdatedEvent = TypedEvent<[
    string,
    number,
    number,
    number
], DelegationParametersUpdatedEventObject>;
export type DelegationParametersUpdatedEventFilter = TypedEventFilter<DelegationParametersUpdatedEvent>;
export interface ExtensionImplementationSetEventObject {
    extensionImpl: string;
}
export type ExtensionImplementationSetEvent = TypedEvent<[
    string
], ExtensionImplementationSetEventObject>;
export type ExtensionImplementationSetEventFilter = TypedEventFilter<ExtensionImplementationSetEvent>;
export interface RebateCollectedEventObject {
    assetHolder: string;
    indexer: string;
    subgraphDeploymentID: string;
    allocationID: string;
    epoch: BigNumber;
    tokens: BigNumber;
    protocolTax: BigNumber;
    curationFees: BigNumber;
    queryFees: BigNumber;
    queryRebates: BigNumber;
    delegationRewards: BigNumber;
}
export type RebateCollectedEvent = TypedEvent<[
    string,
    string,
    string,
    string,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber
], RebateCollectedEventObject>;
export type RebateCollectedEventFilter = TypedEventFilter<RebateCollectedEvent>;
export interface SetOperatorEventObject {
    indexer: string;
    operator: string;
    allowed: boolean;
}
export type SetOperatorEvent = TypedEvent<[
    string,
    string,
    boolean
], SetOperatorEventObject>;
export type SetOperatorEventFilter = TypedEventFilter<SetOperatorEvent>;
export interface SetRewardsDestinationEventObject {
    indexer: string;
    destination: string;
}
export type SetRewardsDestinationEvent = TypedEvent<[
    string,
    string
], SetRewardsDestinationEventObject>;
export type SetRewardsDestinationEventFilter = TypedEventFilter<SetRewardsDestinationEvent>;
export interface SlasherUpdateEventObject {
    caller: string;
    slasher: string;
    allowed: boolean;
}
export type SlasherUpdateEvent = TypedEvent<[
    string,
    string,
    boolean
], SlasherUpdateEventObject>;
export type SlasherUpdateEventFilter = TypedEventFilter<SlasherUpdateEvent>;
export interface StakeDelegatedEventObject {
    indexer: string;
    delegator: string;
    tokens: BigNumber;
    shares: BigNumber;
}
export type StakeDelegatedEvent = TypedEvent<[
    string,
    string,
    BigNumber,
    BigNumber
], StakeDelegatedEventObject>;
export type StakeDelegatedEventFilter = TypedEventFilter<StakeDelegatedEvent>;
export interface StakeDelegatedLockedEventObject {
    indexer: string;
    delegator: string;
    tokens: BigNumber;
    shares: BigNumber;
    until: BigNumber;
}
export type StakeDelegatedLockedEvent = TypedEvent<[
    string,
    string,
    BigNumber,
    BigNumber,
    BigNumber
], StakeDelegatedLockedEventObject>;
export type StakeDelegatedLockedEventFilter = TypedEventFilter<StakeDelegatedLockedEvent>;
export interface StakeDelegatedWithdrawnEventObject {
    indexer: string;
    delegator: string;
    tokens: BigNumber;
}
export type StakeDelegatedWithdrawnEvent = TypedEvent<[
    string,
    string,
    BigNumber
], StakeDelegatedWithdrawnEventObject>;
export type StakeDelegatedWithdrawnEventFilter = TypedEventFilter<StakeDelegatedWithdrawnEvent>;
export interface StakeDepositedEventObject {
    indexer: string;
    tokens: BigNumber;
}
export type StakeDepositedEvent = TypedEvent<[
    string,
    BigNumber
], StakeDepositedEventObject>;
export type StakeDepositedEventFilter = TypedEventFilter<StakeDepositedEvent>;
export interface StakeLockedEventObject {
    indexer: string;
    tokens: BigNumber;
    until: BigNumber;
}
export type StakeLockedEvent = TypedEvent<[
    string,
    BigNumber,
    BigNumber
], StakeLockedEventObject>;
export type StakeLockedEventFilter = TypedEventFilter<StakeLockedEvent>;
export interface StakeSlashedEventObject {
    indexer: string;
    tokens: BigNumber;
    reward: BigNumber;
    beneficiary: string;
}
export type StakeSlashedEvent = TypedEvent<[
    string,
    BigNumber,
    BigNumber,
    string
], StakeSlashedEventObject>;
export type StakeSlashedEventFilter = TypedEventFilter<StakeSlashedEvent>;
export interface StakeWithdrawnEventObject {
    indexer: string;
    tokens: BigNumber;
}
export type StakeWithdrawnEvent = TypedEvent<[
    string,
    BigNumber
], StakeWithdrawnEventObject>;
export type StakeWithdrawnEventFilter = TypedEventFilter<StakeWithdrawnEvent>;
export interface IStaking extends BaseContract {
    connect(signerOrProvider: Signer | Provider | string): this;
    attach(addressOrName: string): this;
    deployed(): Promise<this>;
    interface: IStakingInterface;
    queryFilter<TEvent extends TypedEvent>(event: TypedEventFilter<TEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TEvent>>;
    listeners<TEvent extends TypedEvent>(eventFilter?: TypedEventFilter<TEvent>): Array<TypedListener<TEvent>>;
    listeners(eventName?: string): Array<Listener>;
    removeAllListeners<TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>): this;
    removeAllListeners(eventName?: string): this;
    off: OnEvent<this>;
    on: OnEvent<this>;
    once: OnEvent<this>;
    removeListener: OnEvent<this>;
    functions: {
        allocate(subgraphDeploymentID: PromiseOrValue<BytesLike>, tokens: PromiseOrValue<BigNumberish>, allocationID: PromiseOrValue<string>, metadata: PromiseOrValue<BytesLike>, proof: PromiseOrValue<BytesLike>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        allocateFrom(indexer: PromiseOrValue<string>, subgraphDeploymentID: PromiseOrValue<BytesLike>, tokens: PromiseOrValue<BigNumberish>, allocationID: PromiseOrValue<string>, metadata: PromiseOrValue<BytesLike>, proof: PromiseOrValue<BytesLike>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        allocations(allocationID: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[IStakingData.AllocationStructOutput]>;
        alphaDenominator(overrides?: CallOverrides): Promise<[number]>;
        alphaNumerator(overrides?: CallOverrides): Promise<[number]>;
        closeAllocation(allocationID: PromiseOrValue<string>, poi: PromiseOrValue<BytesLike>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        collect(tokens: PromiseOrValue<BigNumberish>, allocationID: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        controller(overrides?: CallOverrides): Promise<[string]>;
        curationPercentage(overrides?: CallOverrides): Promise<[number]>;
        delegate(indexer: PromiseOrValue<string>, tokens: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        delegationPools(indexer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[IStakingExtension.DelegationPoolReturnStructOutput]>;
        delegationRatio(overrides?: CallOverrides): Promise<[number]>;
        delegationTaxPercentage(overrides?: CallOverrides): Promise<[number]>;
        delegationUnbondingPeriod(overrides?: CallOverrides): Promise<[number]>;
        getAllocation(allocationID: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[IStakingData.AllocationStructOutput]>;
        getAllocationData(allocationID: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean, string, string, BigNumber, BigNumber, BigNumber]>;
        getAllocationState(allocationID: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[number]>;
        getDelegation(indexer: PromiseOrValue<string>, delegator: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[IStakingData.DelegationStructOutput]>;
        getIndexerCapacity(indexer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
        getIndexerStakedTokens(indexer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
        getSubgraphAllocatedTokens(subgraphDeploymentID: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[BigNumber]>;
        getWithdraweableDelegatedTokens(delegation: IStakingData.DelegationStruct, overrides?: CallOverrides): Promise<[BigNumber]>;
        hasStake(indexer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>;
        initialize(controller: PromiseOrValue<string>, minimumIndexerStake: PromiseOrValue<BigNumberish>, thawingPeriod: PromiseOrValue<BigNumberish>, protocolPercentage: PromiseOrValue<BigNumberish>, curationPercentage: PromiseOrValue<BigNumberish>, maxAllocationEpochs: PromiseOrValue<BigNumberish>, delegationUnbondingPeriod: PromiseOrValue<BigNumberish>, delegationRatio: PromiseOrValue<BigNumberish>, rebatesParameters: IStakingData.RebatesParametersStruct, extensionImpl: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        isActiveAllocation(allocationID: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>;
        isAllocation(allocationID: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>;
        isDelegator(indexer: PromiseOrValue<string>, delegator: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>;
        isOperator(operator: PromiseOrValue<string>, indexer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>;
        lambdaDenominator(overrides?: CallOverrides): Promise<[number]>;
        lambdaNumerator(overrides?: CallOverrides): Promise<[number]>;
        maxAllocationEpochs(overrides?: CallOverrides): Promise<[number]>;
        minimumIndexerStake(overrides?: CallOverrides): Promise<[BigNumber]>;
        multicall(data: PromiseOrValue<BytesLike>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        operatorAuth(indexer: PromiseOrValue<string>, maybeOperator: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>;
        protocolPercentage(overrides?: CallOverrides): Promise<[number]>;
        rewardsDestination(indexer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[string]>;
        setController(controller: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setCounterpartStakingAddress(counterpart: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setCurationPercentage(percentage: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setDelegationParameters(indexingRewardCut: PromiseOrValue<BigNumberish>, queryFeeCut: PromiseOrValue<BigNumberish>, arg2: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setDelegationRatio(delegationRatio: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setDelegationTaxPercentage(percentage: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setDelegationUnbondingPeriod(delegationUnbondingPeriod: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setExtensionImpl(extensionImpl: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setMaxAllocationEpochs(maxAllocationEpochs: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setMinimumIndexerStake(minimumIndexerStake: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setOperator(operator: PromiseOrValue<string>, allowed: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setProtocolPercentage(percentage: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setRebateParameters(alphaNumerator: PromiseOrValue<BigNumberish>, alphaDenominator: PromiseOrValue<BigNumberish>, lambdaNumerator: PromiseOrValue<BigNumberish>, lambdaDenominator: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setRewardsDestination(destination: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setSlasher(slasher: PromiseOrValue<string>, allowed: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setThawingPeriod(thawingPeriod: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        slash(indexer: PromiseOrValue<string>, tokens: PromiseOrValue<BigNumberish>, reward: PromiseOrValue<BigNumberish>, beneficiary: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        slashers(maybeSlasher: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>;
        stake(tokens: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        stakeTo(indexer: PromiseOrValue<string>, tokens: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        stakes(indexer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[IStakes.IndexerStructOutput]>;
        subgraphAllocations(subgraphDeploymentId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[BigNumber]>;
        syncAllContracts(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        thawingPeriod(overrides?: CallOverrides): Promise<[number]>;
        undelegate(indexer: PromiseOrValue<string>, shares: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        unstake(tokens: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        withdraw(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        withdrawDelegated(indexer: PromiseOrValue<string>, newIndexer: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
    };
    allocate(subgraphDeploymentID: PromiseOrValue<BytesLike>, tokens: PromiseOrValue<BigNumberish>, allocationID: PromiseOrValue<string>, metadata: PromiseOrValue<BytesLike>, proof: PromiseOrValue<BytesLike>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    allocateFrom(indexer: PromiseOrValue<string>, subgraphDeploymentID: PromiseOrValue<BytesLike>, tokens: PromiseOrValue<BigNumberish>, allocationID: PromiseOrValue<string>, metadata: PromiseOrValue<BytesLike>, proof: PromiseOrValue<BytesLike>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    allocations(allocationID: PromiseOrValue<string>, overrides?: CallOverrides): Promise<IStakingData.AllocationStructOutput>;
    alphaDenominator(overrides?: CallOverrides): Promise<number>;
    alphaNumerator(overrides?: CallOverrides): Promise<number>;
    closeAllocation(allocationID: PromiseOrValue<string>, poi: PromiseOrValue<BytesLike>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    collect(tokens: PromiseOrValue<BigNumberish>, allocationID: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    controller(overrides?: CallOverrides): Promise<string>;
    curationPercentage(overrides?: CallOverrides): Promise<number>;
    delegate(indexer: PromiseOrValue<string>, tokens: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    delegationPools(indexer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<IStakingExtension.DelegationPoolReturnStructOutput>;
    delegationRatio(overrides?: CallOverrides): Promise<number>;
    delegationTaxPercentage(overrides?: CallOverrides): Promise<number>;
    delegationUnbondingPeriod(overrides?: CallOverrides): Promise<number>;
    getAllocation(allocationID: PromiseOrValue<string>, overrides?: CallOverrides): Promise<IStakingData.AllocationStructOutput>;
    getAllocationData(allocationID: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean, string, string, BigNumber, BigNumber, BigNumber]>;
    getAllocationState(allocationID: PromiseOrValue<string>, overrides?: CallOverrides): Promise<number>;
    getDelegation(indexer: PromiseOrValue<string>, delegator: PromiseOrValue<string>, overrides?: CallOverrides): Promise<IStakingData.DelegationStructOutput>;
    getIndexerCapacity(indexer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
    getIndexerStakedTokens(indexer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
    getSubgraphAllocatedTokens(subgraphDeploymentID: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
    getWithdraweableDelegatedTokens(delegation: IStakingData.DelegationStruct, overrides?: CallOverrides): Promise<BigNumber>;
    hasStake(indexer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
    initialize(controller: PromiseOrValue<string>, minimumIndexerStake: PromiseOrValue<BigNumberish>, thawingPeriod: PromiseOrValue<BigNumberish>, protocolPercentage: PromiseOrValue<BigNumberish>, curationPercentage: PromiseOrValue<BigNumberish>, maxAllocationEpochs: PromiseOrValue<BigNumberish>, delegationUnbondingPeriod: PromiseOrValue<BigNumberish>, delegationRatio: PromiseOrValue<BigNumberish>, rebatesParameters: IStakingData.RebatesParametersStruct, extensionImpl: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    isActiveAllocation(allocationID: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
    isAllocation(allocationID: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
    isDelegator(indexer: PromiseOrValue<string>, delegator: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
    isOperator(operator: PromiseOrValue<string>, indexer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
    lambdaDenominator(overrides?: CallOverrides): Promise<number>;
    lambdaNumerator(overrides?: CallOverrides): Promise<number>;
    maxAllocationEpochs(overrides?: CallOverrides): Promise<number>;
    minimumIndexerStake(overrides?: CallOverrides): Promise<BigNumber>;
    multicall(data: PromiseOrValue<BytesLike>[], overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    operatorAuth(indexer: PromiseOrValue<string>, maybeOperator: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
    protocolPercentage(overrides?: CallOverrides): Promise<number>;
    rewardsDestination(indexer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<string>;
    setController(controller: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setCounterpartStakingAddress(counterpart: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setCurationPercentage(percentage: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setDelegationParameters(indexingRewardCut: PromiseOrValue<BigNumberish>, queryFeeCut: PromiseOrValue<BigNumberish>, arg2: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setDelegationRatio(delegationRatio: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setDelegationTaxPercentage(percentage: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setDelegationUnbondingPeriod(delegationUnbondingPeriod: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setExtensionImpl(extensionImpl: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setMaxAllocationEpochs(maxAllocationEpochs: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setMinimumIndexerStake(minimumIndexerStake: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setOperator(operator: PromiseOrValue<string>, allowed: PromiseOrValue<boolean>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setProtocolPercentage(percentage: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setRebateParameters(alphaNumerator: PromiseOrValue<BigNumberish>, alphaDenominator: PromiseOrValue<BigNumberish>, lambdaNumerator: PromiseOrValue<BigNumberish>, lambdaDenominator: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setRewardsDestination(destination: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setSlasher(slasher: PromiseOrValue<string>, allowed: PromiseOrValue<boolean>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setThawingPeriod(thawingPeriod: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    slash(indexer: PromiseOrValue<string>, tokens: PromiseOrValue<BigNumberish>, reward: PromiseOrValue<BigNumberish>, beneficiary: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    slashers(maybeSlasher: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
    stake(tokens: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    stakeTo(indexer: PromiseOrValue<string>, tokens: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    stakes(indexer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<IStakes.IndexerStructOutput>;
    subgraphAllocations(subgraphDeploymentId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
    syncAllContracts(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    thawingPeriod(overrides?: CallOverrides): Promise<number>;
    undelegate(indexer: PromiseOrValue<string>, shares: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    unstake(tokens: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    withdraw(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    withdrawDelegated(indexer: PromiseOrValue<string>, newIndexer: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    callStatic: {
        allocate(subgraphDeploymentID: PromiseOrValue<BytesLike>, tokens: PromiseOrValue<BigNumberish>, allocationID: PromiseOrValue<string>, metadata: PromiseOrValue<BytesLike>, proof: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<void>;
        allocateFrom(indexer: PromiseOrValue<string>, subgraphDeploymentID: PromiseOrValue<BytesLike>, tokens: PromiseOrValue<BigNumberish>, allocationID: PromiseOrValue<string>, metadata: PromiseOrValue<BytesLike>, proof: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<void>;
        allocations(allocationID: PromiseOrValue<string>, overrides?: CallOverrides): Promise<IStakingData.AllocationStructOutput>;
        alphaDenominator(overrides?: CallOverrides): Promise<number>;
        alphaNumerator(overrides?: CallOverrides): Promise<number>;
        closeAllocation(allocationID: PromiseOrValue<string>, poi: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<void>;
        collect(tokens: PromiseOrValue<BigNumberish>, allocationID: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        controller(overrides?: CallOverrides): Promise<string>;
        curationPercentage(overrides?: CallOverrides): Promise<number>;
        delegate(indexer: PromiseOrValue<string>, tokens: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
        delegationPools(indexer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<IStakingExtension.DelegationPoolReturnStructOutput>;
        delegationRatio(overrides?: CallOverrides): Promise<number>;
        delegationTaxPercentage(overrides?: CallOverrides): Promise<number>;
        delegationUnbondingPeriod(overrides?: CallOverrides): Promise<number>;
        getAllocation(allocationID: PromiseOrValue<string>, overrides?: CallOverrides): Promise<IStakingData.AllocationStructOutput>;
        getAllocationData(allocationID: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean, string, string, BigNumber, BigNumber, BigNumber]>;
        getAllocationState(allocationID: PromiseOrValue<string>, overrides?: CallOverrides): Promise<number>;
        getDelegation(indexer: PromiseOrValue<string>, delegator: PromiseOrValue<string>, overrides?: CallOverrides): Promise<IStakingData.DelegationStructOutput>;
        getIndexerCapacity(indexer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        getIndexerStakedTokens(indexer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        getSubgraphAllocatedTokens(subgraphDeploymentID: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
        getWithdraweableDelegatedTokens(delegation: IStakingData.DelegationStruct, overrides?: CallOverrides): Promise<BigNumber>;
        hasStake(indexer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
        initialize(controller: PromiseOrValue<string>, minimumIndexerStake: PromiseOrValue<BigNumberish>, thawingPeriod: PromiseOrValue<BigNumberish>, protocolPercentage: PromiseOrValue<BigNumberish>, curationPercentage: PromiseOrValue<BigNumberish>, maxAllocationEpochs: PromiseOrValue<BigNumberish>, delegationUnbondingPeriod: PromiseOrValue<BigNumberish>, delegationRatio: PromiseOrValue<BigNumberish>, rebatesParameters: IStakingData.RebatesParametersStruct, extensionImpl: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        isActiveAllocation(allocationID: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
        isAllocation(allocationID: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
        isDelegator(indexer: PromiseOrValue<string>, delegator: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
        isOperator(operator: PromiseOrValue<string>, indexer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
        lambdaDenominator(overrides?: CallOverrides): Promise<number>;
        lambdaNumerator(overrides?: CallOverrides): Promise<number>;
        maxAllocationEpochs(overrides?: CallOverrides): Promise<number>;
        minimumIndexerStake(overrides?: CallOverrides): Promise<BigNumber>;
        multicall(data: PromiseOrValue<BytesLike>[], overrides?: CallOverrides): Promise<string[]>;
        operatorAuth(indexer: PromiseOrValue<string>, maybeOperator: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
        protocolPercentage(overrides?: CallOverrides): Promise<number>;
        rewardsDestination(indexer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<string>;
        setController(controller: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        setCounterpartStakingAddress(counterpart: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        setCurationPercentage(percentage: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        setDelegationParameters(indexingRewardCut: PromiseOrValue<BigNumberish>, queryFeeCut: PromiseOrValue<BigNumberish>, arg2: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        setDelegationRatio(delegationRatio: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        setDelegationTaxPercentage(percentage: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        setDelegationUnbondingPeriod(delegationUnbondingPeriod: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        setExtensionImpl(extensionImpl: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        setMaxAllocationEpochs(maxAllocationEpochs: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        setMinimumIndexerStake(minimumIndexerStake: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        setOperator(operator: PromiseOrValue<string>, allowed: PromiseOrValue<boolean>, overrides?: CallOverrides): Promise<void>;
        setProtocolPercentage(percentage: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        setRebateParameters(alphaNumerator: PromiseOrValue<BigNumberish>, alphaDenominator: PromiseOrValue<BigNumberish>, lambdaNumerator: PromiseOrValue<BigNumberish>, lambdaDenominator: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        setRewardsDestination(destination: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        setSlasher(slasher: PromiseOrValue<string>, allowed: PromiseOrValue<boolean>, overrides?: CallOverrides): Promise<void>;
        setThawingPeriod(thawingPeriod: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        slash(indexer: PromiseOrValue<string>, tokens: PromiseOrValue<BigNumberish>, reward: PromiseOrValue<BigNumberish>, beneficiary: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        slashers(maybeSlasher: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
        stake(tokens: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        stakeTo(indexer: PromiseOrValue<string>, tokens: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        stakes(indexer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<IStakes.IndexerStructOutput>;
        subgraphAllocations(subgraphDeploymentId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
        syncAllContracts(overrides?: CallOverrides): Promise<void>;
        thawingPeriod(overrides?: CallOverrides): Promise<number>;
        undelegate(indexer: PromiseOrValue<string>, shares: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
        unstake(tokens: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        withdraw(overrides?: CallOverrides): Promise<void>;
        withdrawDelegated(indexer: PromiseOrValue<string>, newIndexer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
    };
    filters: {
        "AllocationClosed(address,bytes32,uint256,uint256,address,address,bytes32,bool)"(indexer?: PromiseOrValue<string> | null, subgraphDeploymentID?: PromiseOrValue<BytesLike> | null, epoch?: null, tokens?: null, allocationID?: PromiseOrValue<string> | null, sender?: null, poi?: null, isPublic?: null): AllocationClosedEventFilter;
        AllocationClosed(indexer?: PromiseOrValue<string> | null, subgraphDeploymentID?: PromiseOrValue<BytesLike> | null, epoch?: null, tokens?: null, allocationID?: PromiseOrValue<string> | null, sender?: null, poi?: null, isPublic?: null): AllocationClosedEventFilter;
        "AllocationCreated(address,bytes32,uint256,uint256,address,bytes32)"(indexer?: PromiseOrValue<string> | null, subgraphDeploymentID?: PromiseOrValue<BytesLike> | null, epoch?: null, tokens?: null, allocationID?: PromiseOrValue<string> | null, metadata?: null): AllocationCreatedEventFilter;
        AllocationCreated(indexer?: PromiseOrValue<string> | null, subgraphDeploymentID?: PromiseOrValue<BytesLike> | null, epoch?: null, tokens?: null, allocationID?: PromiseOrValue<string> | null, metadata?: null): AllocationCreatedEventFilter;
        "DelegationParametersUpdated(address,uint32,uint32,uint32)"(indexer?: PromiseOrValue<string> | null, indexingRewardCut?: null, queryFeeCut?: null, __DEPRECATED_cooldownBlocks?: null): DelegationParametersUpdatedEventFilter;
        DelegationParametersUpdated(indexer?: PromiseOrValue<string> | null, indexingRewardCut?: null, queryFeeCut?: null, __DEPRECATED_cooldownBlocks?: null): DelegationParametersUpdatedEventFilter;
        "ExtensionImplementationSet(address)"(extensionImpl?: PromiseOrValue<string> | null): ExtensionImplementationSetEventFilter;
        ExtensionImplementationSet(extensionImpl?: PromiseOrValue<string> | null): ExtensionImplementationSetEventFilter;
        "RebateCollected(address,address,bytes32,address,uint256,uint256,uint256,uint256,uint256,uint256,uint256)"(assetHolder?: null, indexer?: PromiseOrValue<string> | null, subgraphDeploymentID?: PromiseOrValue<BytesLike> | null, allocationID?: PromiseOrValue<string> | null, epoch?: null, tokens?: null, protocolTax?: null, curationFees?: null, queryFees?: null, queryRebates?: null, delegationRewards?: null): RebateCollectedEventFilter;
        RebateCollected(assetHolder?: null, indexer?: PromiseOrValue<string> | null, subgraphDeploymentID?: PromiseOrValue<BytesLike> | null, allocationID?: PromiseOrValue<string> | null, epoch?: null, tokens?: null, protocolTax?: null, curationFees?: null, queryFees?: null, queryRebates?: null, delegationRewards?: null): RebateCollectedEventFilter;
        "SetOperator(address,address,bool)"(indexer?: PromiseOrValue<string> | null, operator?: PromiseOrValue<string> | null, allowed?: null): SetOperatorEventFilter;
        SetOperator(indexer?: PromiseOrValue<string> | null, operator?: PromiseOrValue<string> | null, allowed?: null): SetOperatorEventFilter;
        "SetRewardsDestination(address,address)"(indexer?: PromiseOrValue<string> | null, destination?: PromiseOrValue<string> | null): SetRewardsDestinationEventFilter;
        SetRewardsDestination(indexer?: PromiseOrValue<string> | null, destination?: PromiseOrValue<string> | null): SetRewardsDestinationEventFilter;
        "SlasherUpdate(address,address,bool)"(caller?: PromiseOrValue<string> | null, slasher?: PromiseOrValue<string> | null, allowed?: null): SlasherUpdateEventFilter;
        SlasherUpdate(caller?: PromiseOrValue<string> | null, slasher?: PromiseOrValue<string> | null, allowed?: null): SlasherUpdateEventFilter;
        "StakeDelegated(address,address,uint256,uint256)"(indexer?: PromiseOrValue<string> | null, delegator?: PromiseOrValue<string> | null, tokens?: null, shares?: null): StakeDelegatedEventFilter;
        StakeDelegated(indexer?: PromiseOrValue<string> | null, delegator?: PromiseOrValue<string> | null, tokens?: null, shares?: null): StakeDelegatedEventFilter;
        "StakeDelegatedLocked(address,address,uint256,uint256,uint256)"(indexer?: PromiseOrValue<string> | null, delegator?: PromiseOrValue<string> | null, tokens?: null, shares?: null, until?: null): StakeDelegatedLockedEventFilter;
        StakeDelegatedLocked(indexer?: PromiseOrValue<string> | null, delegator?: PromiseOrValue<string> | null, tokens?: null, shares?: null, until?: null): StakeDelegatedLockedEventFilter;
        "StakeDelegatedWithdrawn(address,address,uint256)"(indexer?: PromiseOrValue<string> | null, delegator?: PromiseOrValue<string> | null, tokens?: null): StakeDelegatedWithdrawnEventFilter;
        StakeDelegatedWithdrawn(indexer?: PromiseOrValue<string> | null, delegator?: PromiseOrValue<string> | null, tokens?: null): StakeDelegatedWithdrawnEventFilter;
        "StakeDeposited(address,uint256)"(indexer?: PromiseOrValue<string> | null, tokens?: null): StakeDepositedEventFilter;
        StakeDeposited(indexer?: PromiseOrValue<string> | null, tokens?: null): StakeDepositedEventFilter;
        "StakeLocked(address,uint256,uint256)"(indexer?: PromiseOrValue<string> | null, tokens?: null, until?: null): StakeLockedEventFilter;
        StakeLocked(indexer?: PromiseOrValue<string> | null, tokens?: null, until?: null): StakeLockedEventFilter;
        "StakeSlashed(address,uint256,uint256,address)"(indexer?: PromiseOrValue<string> | null, tokens?: null, reward?: null, beneficiary?: null): StakeSlashedEventFilter;
        StakeSlashed(indexer?: PromiseOrValue<string> | null, tokens?: null, reward?: null, beneficiary?: null): StakeSlashedEventFilter;
        "StakeWithdrawn(address,uint256)"(indexer?: PromiseOrValue<string> | null, tokens?: null): StakeWithdrawnEventFilter;
        StakeWithdrawn(indexer?: PromiseOrValue<string> | null, tokens?: null): StakeWithdrawnEventFilter;
    };
    estimateGas: {
        allocate(subgraphDeploymentID: PromiseOrValue<BytesLike>, tokens: PromiseOrValue<BigNumberish>, allocationID: PromiseOrValue<string>, metadata: PromiseOrValue<BytesLike>, proof: PromiseOrValue<BytesLike>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        allocateFrom(indexer: PromiseOrValue<string>, subgraphDeploymentID: PromiseOrValue<BytesLike>, tokens: PromiseOrValue<BigNumberish>, allocationID: PromiseOrValue<string>, metadata: PromiseOrValue<BytesLike>, proof: PromiseOrValue<BytesLike>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        allocations(allocationID: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        alphaDenominator(overrides?: CallOverrides): Promise<BigNumber>;
        alphaNumerator(overrides?: CallOverrides): Promise<BigNumber>;
        closeAllocation(allocationID: PromiseOrValue<string>, poi: PromiseOrValue<BytesLike>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        collect(tokens: PromiseOrValue<BigNumberish>, allocationID: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        controller(overrides?: CallOverrides): Promise<BigNumber>;
        curationPercentage(overrides?: CallOverrides): Promise<BigNumber>;
        delegate(indexer: PromiseOrValue<string>, tokens: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        delegationPools(indexer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        delegationRatio(overrides?: CallOverrides): Promise<BigNumber>;
        delegationTaxPercentage(overrides?: CallOverrides): Promise<BigNumber>;
        delegationUnbondingPeriod(overrides?: CallOverrides): Promise<BigNumber>;
        getAllocation(allocationID: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        getAllocationData(allocationID: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        getAllocationState(allocationID: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        getDelegation(indexer: PromiseOrValue<string>, delegator: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        getIndexerCapacity(indexer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        getIndexerStakedTokens(indexer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        getSubgraphAllocatedTokens(subgraphDeploymentID: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
        getWithdraweableDelegatedTokens(delegation: IStakingData.DelegationStruct, overrides?: CallOverrides): Promise<BigNumber>;
        hasStake(indexer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        initialize(controller: PromiseOrValue<string>, minimumIndexerStake: PromiseOrValue<BigNumberish>, thawingPeriod: PromiseOrValue<BigNumberish>, protocolPercentage: PromiseOrValue<BigNumberish>, curationPercentage: PromiseOrValue<BigNumberish>, maxAllocationEpochs: PromiseOrValue<BigNumberish>, delegationUnbondingPeriod: PromiseOrValue<BigNumberish>, delegationRatio: PromiseOrValue<BigNumberish>, rebatesParameters: IStakingData.RebatesParametersStruct, extensionImpl: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        isActiveAllocation(allocationID: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        isAllocation(allocationID: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        isDelegator(indexer: PromiseOrValue<string>, delegator: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        isOperator(operator: PromiseOrValue<string>, indexer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        lambdaDenominator(overrides?: CallOverrides): Promise<BigNumber>;
        lambdaNumerator(overrides?: CallOverrides): Promise<BigNumber>;
        maxAllocationEpochs(overrides?: CallOverrides): Promise<BigNumber>;
        minimumIndexerStake(overrides?: CallOverrides): Promise<BigNumber>;
        multicall(data: PromiseOrValue<BytesLike>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        operatorAuth(indexer: PromiseOrValue<string>, maybeOperator: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        protocolPercentage(overrides?: CallOverrides): Promise<BigNumber>;
        rewardsDestination(indexer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        setController(controller: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setCounterpartStakingAddress(counterpart: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setCurationPercentage(percentage: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setDelegationParameters(indexingRewardCut: PromiseOrValue<BigNumberish>, queryFeeCut: PromiseOrValue<BigNumberish>, arg2: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setDelegationRatio(delegationRatio: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setDelegationTaxPercentage(percentage: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setDelegationUnbondingPeriod(delegationUnbondingPeriod: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setExtensionImpl(extensionImpl: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setMaxAllocationEpochs(maxAllocationEpochs: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setMinimumIndexerStake(minimumIndexerStake: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setOperator(operator: PromiseOrValue<string>, allowed: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setProtocolPercentage(percentage: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setRebateParameters(alphaNumerator: PromiseOrValue<BigNumberish>, alphaDenominator: PromiseOrValue<BigNumberish>, lambdaNumerator: PromiseOrValue<BigNumberish>, lambdaDenominator: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setRewardsDestination(destination: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setSlasher(slasher: PromiseOrValue<string>, allowed: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setThawingPeriod(thawingPeriod: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        slash(indexer: PromiseOrValue<string>, tokens: PromiseOrValue<BigNumberish>, reward: PromiseOrValue<BigNumberish>, beneficiary: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        slashers(maybeSlasher: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        stake(tokens: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        stakeTo(indexer: PromiseOrValue<string>, tokens: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        stakes(indexer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        subgraphAllocations(subgraphDeploymentId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
        syncAllContracts(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        thawingPeriod(overrides?: CallOverrides): Promise<BigNumber>;
        undelegate(indexer: PromiseOrValue<string>, shares: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        unstake(tokens: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        withdraw(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        withdrawDelegated(indexer: PromiseOrValue<string>, newIndexer: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
    };
    populateTransaction: {
        allocate(subgraphDeploymentID: PromiseOrValue<BytesLike>, tokens: PromiseOrValue<BigNumberish>, allocationID: PromiseOrValue<string>, metadata: PromiseOrValue<BytesLike>, proof: PromiseOrValue<BytesLike>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        allocateFrom(indexer: PromiseOrValue<string>, subgraphDeploymentID: PromiseOrValue<BytesLike>, tokens: PromiseOrValue<BigNumberish>, allocationID: PromiseOrValue<string>, metadata: PromiseOrValue<BytesLike>, proof: PromiseOrValue<BytesLike>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        allocations(allocationID: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        alphaDenominator(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        alphaNumerator(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        closeAllocation(allocationID: PromiseOrValue<string>, poi: PromiseOrValue<BytesLike>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        collect(tokens: PromiseOrValue<BigNumberish>, allocationID: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        controller(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        curationPercentage(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        delegate(indexer: PromiseOrValue<string>, tokens: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        delegationPools(indexer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        delegationRatio(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        delegationTaxPercentage(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        delegationUnbondingPeriod(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getAllocation(allocationID: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getAllocationData(allocationID: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getAllocationState(allocationID: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getDelegation(indexer: PromiseOrValue<string>, delegator: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getIndexerCapacity(indexer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getIndexerStakedTokens(indexer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getSubgraphAllocatedTokens(subgraphDeploymentID: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getWithdraweableDelegatedTokens(delegation: IStakingData.DelegationStruct, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        hasStake(indexer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        initialize(controller: PromiseOrValue<string>, minimumIndexerStake: PromiseOrValue<BigNumberish>, thawingPeriod: PromiseOrValue<BigNumberish>, protocolPercentage: PromiseOrValue<BigNumberish>, curationPercentage: PromiseOrValue<BigNumberish>, maxAllocationEpochs: PromiseOrValue<BigNumberish>, delegationUnbondingPeriod: PromiseOrValue<BigNumberish>, delegationRatio: PromiseOrValue<BigNumberish>, rebatesParameters: IStakingData.RebatesParametersStruct, extensionImpl: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        isActiveAllocation(allocationID: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        isAllocation(allocationID: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        isDelegator(indexer: PromiseOrValue<string>, delegator: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        isOperator(operator: PromiseOrValue<string>, indexer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        lambdaDenominator(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        lambdaNumerator(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        maxAllocationEpochs(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        minimumIndexerStake(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        multicall(data: PromiseOrValue<BytesLike>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        operatorAuth(indexer: PromiseOrValue<string>, maybeOperator: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        protocolPercentage(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        rewardsDestination(indexer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        setController(controller: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setCounterpartStakingAddress(counterpart: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setCurationPercentage(percentage: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setDelegationParameters(indexingRewardCut: PromiseOrValue<BigNumberish>, queryFeeCut: PromiseOrValue<BigNumberish>, arg2: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setDelegationRatio(delegationRatio: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setDelegationTaxPercentage(percentage: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setDelegationUnbondingPeriod(delegationUnbondingPeriod: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setExtensionImpl(extensionImpl: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setMaxAllocationEpochs(maxAllocationEpochs: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setMinimumIndexerStake(minimumIndexerStake: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setOperator(operator: PromiseOrValue<string>, allowed: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setProtocolPercentage(percentage: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setRebateParameters(alphaNumerator: PromiseOrValue<BigNumberish>, alphaDenominator: PromiseOrValue<BigNumberish>, lambdaNumerator: PromiseOrValue<BigNumberish>, lambdaDenominator: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setRewardsDestination(destination: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setSlasher(slasher: PromiseOrValue<string>, allowed: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setThawingPeriod(thawingPeriod: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        slash(indexer: PromiseOrValue<string>, tokens: PromiseOrValue<BigNumberish>, reward: PromiseOrValue<BigNumberish>, beneficiary: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        slashers(maybeSlasher: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        stake(tokens: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        stakeTo(indexer: PromiseOrValue<string>, tokens: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        stakes(indexer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        subgraphAllocations(subgraphDeploymentId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        syncAllContracts(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        thawingPeriod(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        undelegate(indexer: PromiseOrValue<string>, shares: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        unstake(tokens: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        withdraw(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        withdrawDelegated(indexer: PromiseOrValue<string>, newIndexer: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
    };
}
//# sourceMappingURL=IStaking.d.ts.map