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;
    };
}
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 IStakingExtensionInterface extends utils.Interface {
    functions: {
        "allocations(address)": FunctionFragment;
        "alphaDenominator()": FunctionFragment;
        "alphaNumerator()": FunctionFragment;
        "curationPercentage()": FunctionFragment;
        "delegate(address,uint256)": FunctionFragment;
        "delegationPools(address)": FunctionFragment;
        "delegationRatio()": FunctionFragment;
        "delegationTaxPercentage()": FunctionFragment;
        "delegationUnbondingPeriod()": FunctionFragment;
        "getDelegation(address,address)": FunctionFragment;
        "getWithdraweableDelegatedTokens((uint256,uint256,uint256))": FunctionFragment;
        "isDelegator(address,address)": FunctionFragment;
        "lambdaDenominator()": FunctionFragment;
        "lambdaNumerator()": FunctionFragment;
        "maxAllocationEpochs()": FunctionFragment;
        "minimumIndexerStake()": FunctionFragment;
        "operatorAuth(address,address)": FunctionFragment;
        "protocolPercentage()": FunctionFragment;
        "rewardsDestination(address)": FunctionFragment;
        "setDelegationRatio(uint32)": FunctionFragment;
        "setDelegationTaxPercentage(uint32)": FunctionFragment;
        "setDelegationUnbondingPeriod(uint32)": FunctionFragment;
        "setSlasher(address,bool)": FunctionFragment;
        "slash(address,uint256,uint256,address)": FunctionFragment;
        "slashers(address)": FunctionFragment;
        "stakes(address)": FunctionFragment;
        "subgraphAllocations(bytes32)": FunctionFragment;
        "thawingPeriod()": FunctionFragment;
        "undelegate(address,uint256)": FunctionFragment;
        "withdrawDelegated(address,address)": FunctionFragment;
    };
    getFunction(nameOrSignatureOrTopic: "allocations" | "alphaDenominator" | "alphaNumerator" | "curationPercentage" | "delegate" | "delegationPools" | "delegationRatio" | "delegationTaxPercentage" | "delegationUnbondingPeriod" | "getDelegation" | "getWithdraweableDelegatedTokens" | "isDelegator" | "lambdaDenominator" | "lambdaNumerator" | "maxAllocationEpochs" | "minimumIndexerStake" | "operatorAuth" | "protocolPercentage" | "rewardsDestination" | "setDelegationRatio" | "setDelegationTaxPercentage" | "setDelegationUnbondingPeriod" | "setSlasher" | "slash" | "slashers" | "stakes" | "subgraphAllocations" | "thawingPeriod" | "undelegate" | "withdrawDelegated"): FunctionFragment;
    encodeFunctionData(functionFragment: "allocations", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "alphaDenominator", values?: undefined): string;
    encodeFunctionData(functionFragment: "alphaNumerator", 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: "getDelegation", values: [PromiseOrValue<string>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "getWithdraweableDelegatedTokens", values: [IStakingData.DelegationStruct]): string;
    encodeFunctionData(functionFragment: "isDelegator", 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: "operatorAuth", values: [PromiseOrValue<string>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "protocolPercentage", values?: undefined): string;
    encodeFunctionData(functionFragment: "rewardsDestination", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "setDelegationRatio", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "setDelegationTaxPercentage", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "setDelegationUnbondingPeriod", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "setSlasher", values: [PromiseOrValue<string>, PromiseOrValue<boolean>]): string;
    encodeFunctionData(functionFragment: "slash", values: [
        PromiseOrValue<string>,
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<string>
    ]): string;
    encodeFunctionData(functionFragment: "slashers", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "stakes", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "subgraphAllocations", values: [PromiseOrValue<BytesLike>]): string;
    encodeFunctionData(functionFragment: "thawingPeriod", values?: undefined): string;
    encodeFunctionData(functionFragment: "undelegate", values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "withdrawDelegated", values: [PromiseOrValue<string>, PromiseOrValue<string>]): string;
    decodeFunctionResult(functionFragment: "allocations", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "alphaDenominator", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "alphaNumerator", 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: "getDelegation", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getWithdraweableDelegatedTokens", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "isDelegator", 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: "operatorAuth", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "protocolPercentage", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "rewardsDestination", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setDelegationRatio", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setDelegationTaxPercentage", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setDelegationUnbondingPeriod", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setSlasher", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "slash", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "slashers", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "stakes", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "subgraphAllocations", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "thawingPeriod", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "undelegate", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "withdrawDelegated", data: BytesLike): Result;
    events: {
        "SlasherUpdate(address,address,bool)": EventFragment;
        "StakeDelegated(address,address,uint256,uint256)": EventFragment;
        "StakeDelegatedLocked(address,address,uint256,uint256,uint256)": EventFragment;
        "StakeDelegatedWithdrawn(address,address,uint256)": EventFragment;
        "StakeSlashed(address,uint256,uint256,address)": EventFragment;
    };
    getEvent(nameOrSignatureOrTopic: "SlasherUpdate"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "StakeDelegated"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "StakeDelegatedLocked"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "StakeDelegatedWithdrawn"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "StakeSlashed"): EventFragment;
}
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 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 IStakingExtension extends BaseContract {
    connect(signerOrProvider: Signer | Provider | string): this;
    attach(addressOrName: string): this;
    deployed(): Promise<this>;
    interface: IStakingExtensionInterface;
    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: {
        allocations(allocationID: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[IStakingData.AllocationStructOutput]>;
        alphaDenominator(overrides?: CallOverrides): Promise<[number]>;
        alphaNumerator(overrides?: CallOverrides): Promise<[number]>;
        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]>;
        getDelegation(indexer: PromiseOrValue<string>, delegator: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[IStakingData.DelegationStructOutput]>;
        getWithdraweableDelegatedTokens(delegation: IStakingData.DelegationStruct, overrides?: CallOverrides): Promise<[BigNumber]>;
        isDelegator(indexer: PromiseOrValue<string>, delegator: 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]>;
        operatorAuth(indexer: PromiseOrValue<string>, maybeOperator: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>;
        protocolPercentage(overrides?: CallOverrides): Promise<[number]>;
        rewardsDestination(indexer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[string]>;
        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>;
        setSlasher(slasher: PromiseOrValue<string>, allowed: PromiseOrValue<boolean>, 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]>;
        stakes(indexer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[IStakes.IndexerStructOutput]>;
        subgraphAllocations(subgraphDeploymentId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[BigNumber]>;
        thawingPeriod(overrides?: CallOverrides): Promise<[number]>;
        undelegate(indexer: PromiseOrValue<string>, shares: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        withdrawDelegated(indexer: PromiseOrValue<string>, newIndexer: PromiseOrValue<string>, 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>;
    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>;
    getDelegation(indexer: PromiseOrValue<string>, delegator: PromiseOrValue<string>, overrides?: CallOverrides): Promise<IStakingData.DelegationStructOutput>;
    getWithdraweableDelegatedTokens(delegation: IStakingData.DelegationStruct, overrides?: CallOverrides): Promise<BigNumber>;
    isDelegator(indexer: PromiseOrValue<string>, delegator: 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>;
    operatorAuth(indexer: PromiseOrValue<string>, maybeOperator: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
    protocolPercentage(overrides?: CallOverrides): Promise<number>;
    rewardsDestination(indexer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<string>;
    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>;
    setSlasher(slasher: PromiseOrValue<string>, allowed: PromiseOrValue<boolean>, 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>;
    stakes(indexer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<IStakes.IndexerStructOutput>;
    subgraphAllocations(subgraphDeploymentId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
    thawingPeriod(overrides?: CallOverrides): Promise<number>;
    undelegate(indexer: PromiseOrValue<string>, shares: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    withdrawDelegated(indexer: PromiseOrValue<string>, newIndexer: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    callStatic: {
        allocations(allocationID: PromiseOrValue<string>, overrides?: CallOverrides): Promise<IStakingData.AllocationStructOutput>;
        alphaDenominator(overrides?: CallOverrides): Promise<number>;
        alphaNumerator(overrides?: CallOverrides): Promise<number>;
        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>;
        getDelegation(indexer: PromiseOrValue<string>, delegator: PromiseOrValue<string>, overrides?: CallOverrides): Promise<IStakingData.DelegationStructOutput>;
        getWithdraweableDelegatedTokens(delegation: IStakingData.DelegationStruct, overrides?: CallOverrides): Promise<BigNumber>;
        isDelegator(indexer: PromiseOrValue<string>, delegator: 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>;
        operatorAuth(indexer: PromiseOrValue<string>, maybeOperator: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
        protocolPercentage(overrides?: CallOverrides): Promise<number>;
        rewardsDestination(indexer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<string>;
        setDelegationRatio(delegationRatio: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        setDelegationTaxPercentage(percentage: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        setDelegationUnbondingPeriod(delegationUnbondingPeriod: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        setSlasher(slasher: PromiseOrValue<string>, allowed: PromiseOrValue<boolean>, 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>;
        stakes(indexer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<IStakes.IndexerStructOutput>;
        subgraphAllocations(subgraphDeploymentId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
        thawingPeriod(overrides?: CallOverrides): Promise<number>;
        undelegate(indexer: PromiseOrValue<string>, shares: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
        withdrawDelegated(indexer: PromiseOrValue<string>, newIndexer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
    };
    filters: {
        "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;
        "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;
    };
    estimateGas: {
        allocations(allocationID: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        alphaDenominator(overrides?: CallOverrides): Promise<BigNumber>;
        alphaNumerator(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>;
        getDelegation(indexer: PromiseOrValue<string>, delegator: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        getWithdraweableDelegatedTokens(delegation: IStakingData.DelegationStruct, overrides?: CallOverrides): Promise<BigNumber>;
        isDelegator(indexer: PromiseOrValue<string>, delegator: 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>;
        operatorAuth(indexer: PromiseOrValue<string>, maybeOperator: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        protocolPercentage(overrides?: CallOverrides): Promise<BigNumber>;
        rewardsDestination(indexer: PromiseOrValue<string>, overrides?: CallOverrides): 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>;
        setSlasher(slasher: PromiseOrValue<string>, allowed: PromiseOrValue<boolean>, 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>;
        stakes(indexer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        subgraphAllocations(subgraphDeploymentId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
        thawingPeriod(overrides?: CallOverrides): Promise<BigNumber>;
        undelegate(indexer: PromiseOrValue<string>, shares: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        withdrawDelegated(indexer: PromiseOrValue<string>, newIndexer: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
    };
    populateTransaction: {
        allocations(allocationID: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        alphaDenominator(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        alphaNumerator(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>;
        getDelegation(indexer: PromiseOrValue<string>, delegator: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getWithdraweableDelegatedTokens(delegation: IStakingData.DelegationStruct, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        isDelegator(indexer: PromiseOrValue<string>, delegator: 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>;
        operatorAuth(indexer: PromiseOrValue<string>, maybeOperator: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        protocolPercentage(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        rewardsDestination(indexer: PromiseOrValue<string>, overrides?: CallOverrides): 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>;
        setSlasher(slasher: PromiseOrValue<string>, allowed: PromiseOrValue<boolean>, 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>;
        stakes(indexer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        subgraphAllocations(subgraphDeploymentId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        thawingPeriod(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        undelegate(indexer: PromiseOrValue<string>, shares: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        withdrawDelegated(indexer: PromiseOrValue<string>, newIndexer: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
    };
}
//# sourceMappingURL=IStakingExtension.d.ts.map