import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, 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 type MetaTransactionStruct = {
    relayer: PromiseOrValue<string>;
    deposit: PromiseOrValue<BigNumberish>;
};
export type MetaTransactionStructOutput = [string, BigNumber] & {
    relayer: string;
    deposit: BigNumber;
};
export interface IInfiniteRoundInterface extends utils.Interface {
    functions: {
        "finalizedAt()": FunctionFragment;
        "startTimestamp()": FunctionFragment;
        "state()": FunctionFragment;
        "votePeriodDuration()": FunctionFragment;
    };
    getFunction(nameOrSignatureOrTopic: "finalizedAt" | "startTimestamp" | "state" | "votePeriodDuration"): FunctionFragment;
    encodeFunctionData(functionFragment: "finalizedAt", values?: undefined): string;
    encodeFunctionData(functionFragment: "startTimestamp", values?: undefined): string;
    encodeFunctionData(functionFragment: "state", values?: undefined): string;
    encodeFunctionData(functionFragment: "votePeriodDuration", values?: undefined): string;
    decodeFunctionResult(functionFragment: "finalizedAt", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "startTimestamp", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "state", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "votePeriodDuration", data: BytesLike): Result;
    events: {
        "RoundCancelled()": EventFragment;
        "RoundEmergencyCancelled()": EventFragment;
        "RoundFinalizationStarted()": EventFragment;
        "RoundFinalized()": EventFragment;
        "RoundRegistered(tuple,uint248,uint256[],uint256[],uint256[],uint256[],uint40,uint40,uint248,uint248)": EventFragment;
        "WinnersUpdated(uint64)": EventFragment;
    };
    getEvent(nameOrSignatureOrTopic: "RoundCancelled"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "RoundEmergencyCancelled"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "RoundFinalizationStarted"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "RoundFinalized"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "RoundRegistered"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "WinnersUpdated"): EventFragment;
}
export interface RoundCancelledEventObject {
}
export type RoundCancelledEvent = TypedEvent<[], RoundCancelledEventObject>;
export type RoundCancelledEventFilter = TypedEventFilter<RoundCancelledEvent>;
export interface RoundEmergencyCancelledEventObject {
}
export type RoundEmergencyCancelledEvent = TypedEvent<[
], RoundEmergencyCancelledEventObject>;
export type RoundEmergencyCancelledEventFilter = TypedEventFilter<RoundEmergencyCancelledEvent>;
export interface RoundFinalizationStartedEventObject {
}
export type RoundFinalizationStartedEvent = TypedEvent<[
], RoundFinalizationStartedEventObject>;
export type RoundFinalizationStartedEventFilter = TypedEventFilter<RoundFinalizationStartedEvent>;
export interface RoundFinalizedEventObject {
}
export type RoundFinalizedEvent = TypedEvent<[], RoundFinalizedEventObject>;
export type RoundFinalizedEventFilter = TypedEventFilter<RoundFinalizedEvent>;
export interface RoundRegisteredEventObject {
    metaTx: MetaTransactionStructOutput;
    proposalThreshold: BigNumber;
    proposingStrategies: BigNumber[];
    proposingStrategyParamsFlat: BigNumber[];
    votingStrategies: BigNumber[];
    votingStrategyParamsFlat: BigNumber[];
    startTimestamp: number;
    votePeriodDuration: number;
    quorumFor: BigNumber;
    quorumAgainst: BigNumber;
}
export type RoundRegisteredEvent = TypedEvent<[
    MetaTransactionStructOutput,
    BigNumber,
    BigNumber[],
    BigNumber[],
    BigNumber[],
    BigNumber[],
    number,
    number,
    BigNumber,
    BigNumber
], RoundRegisteredEventObject>;
export type RoundRegisteredEventFilter = TypedEventFilter<RoundRegisteredEvent>;
export interface WinnersUpdatedEventObject {
    winnerCount: BigNumber;
}
export type WinnersUpdatedEvent = TypedEvent<[
    BigNumber
], WinnersUpdatedEventObject>;
export type WinnersUpdatedEventFilter = TypedEventFilter<WinnersUpdatedEvent>;
export interface IInfiniteRound extends BaseContract {
    connect(signerOrProvider: Signer | Provider | string): this;
    attach(addressOrName: string): this;
    deployed(): Promise<this>;
    interface: IInfiniteRoundInterface;
    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: {
        finalizedAt(overrides?: CallOverrides): Promise<[number]>;
        startTimestamp(overrides?: CallOverrides): Promise<[number]>;
        state(overrides?: CallOverrides): Promise<[number]>;
        votePeriodDuration(overrides?: CallOverrides): Promise<[number]>;
    };
    finalizedAt(overrides?: CallOverrides): Promise<number>;
    startTimestamp(overrides?: CallOverrides): Promise<number>;
    state(overrides?: CallOverrides): Promise<number>;
    votePeriodDuration(overrides?: CallOverrides): Promise<number>;
    callStatic: {
        finalizedAt(overrides?: CallOverrides): Promise<number>;
        startTimestamp(overrides?: CallOverrides): Promise<number>;
        state(overrides?: CallOverrides): Promise<number>;
        votePeriodDuration(overrides?: CallOverrides): Promise<number>;
    };
    filters: {
        "RoundCancelled()"(): RoundCancelledEventFilter;
        RoundCancelled(): RoundCancelledEventFilter;
        "RoundEmergencyCancelled()"(): RoundEmergencyCancelledEventFilter;
        RoundEmergencyCancelled(): RoundEmergencyCancelledEventFilter;
        "RoundFinalizationStarted()"(): RoundFinalizationStartedEventFilter;
        RoundFinalizationStarted(): RoundFinalizationStartedEventFilter;
        "RoundFinalized()"(): RoundFinalizedEventFilter;
        RoundFinalized(): RoundFinalizedEventFilter;
        "RoundRegistered(tuple,uint248,uint256[],uint256[],uint256[],uint256[],uint40,uint40,uint248,uint248)"(metaTx?: null, proposalThreshold?: null, proposingStrategies?: null, proposingStrategyParamsFlat?: null, votingStrategies?: null, votingStrategyParamsFlat?: null, startTimestamp?: null, votePeriodDuration?: null, quorumFor?: null, quorumAgainst?: null): RoundRegisteredEventFilter;
        RoundRegistered(metaTx?: null, proposalThreshold?: null, proposingStrategies?: null, proposingStrategyParamsFlat?: null, votingStrategies?: null, votingStrategyParamsFlat?: null, startTimestamp?: null, votePeriodDuration?: null, quorumFor?: null, quorumAgainst?: null): RoundRegisteredEventFilter;
        "WinnersUpdated(uint64)"(winnerCount?: null): WinnersUpdatedEventFilter;
        WinnersUpdated(winnerCount?: null): WinnersUpdatedEventFilter;
    };
    estimateGas: {
        finalizedAt(overrides?: CallOverrides): Promise<BigNumber>;
        startTimestamp(overrides?: CallOverrides): Promise<BigNumber>;
        state(overrides?: CallOverrides): Promise<BigNumber>;
        votePeriodDuration(overrides?: CallOverrides): Promise<BigNumber>;
    };
    populateTransaction: {
        finalizedAt(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        startTimestamp(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        state(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        votePeriodDuration(overrides?: CallOverrides): Promise<PopulatedTransaction>;
    };
}