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 PoolWithMultipleWinnersBuilder {
    type CompoundPrizePoolConfigStruct = {
        cToken: PromiseOrValue<string>;
        maxExitFeeMantissa: PromiseOrValue<BigNumberish>;
    };
    type CompoundPrizePoolConfigStructOutput = [string, BigNumber] & {
        cToken: string;
        maxExitFeeMantissa: BigNumber;
    };
    type StakePrizePoolConfigStruct = {
        token: PromiseOrValue<string>;
        maxExitFeeMantissa: PromiseOrValue<BigNumberish>;
    };
    type StakePrizePoolConfigStructOutput = [string, BigNumber] & {
        token: string;
        maxExitFeeMantissa: BigNumber;
    };
    type YieldSourcePrizePoolConfigStruct = {
        yieldSource: PromiseOrValue<string>;
        maxExitFeeMantissa: PromiseOrValue<BigNumberish>;
    };
    type YieldSourcePrizePoolConfigStructOutput = [string, BigNumber] & {
        yieldSource: string;
        maxExitFeeMantissa: BigNumber;
    };
}
export declare namespace PrizeSplit {
    type PrizeSplitConfigStruct = {
        target: PromiseOrValue<string>;
        percentage: PromiseOrValue<BigNumberish>;
        token: PromiseOrValue<BigNumberish>;
    };
    type PrizeSplitConfigStructOutput = [string, number, number] & {
        target: string;
        percentage: number;
        token: number;
    };
}
export declare namespace MultipleWinnersBuilder {
    type MultipleWinnersConfigStruct = {
        rngService: PromiseOrValue<string>;
        prizePeriodStart: PromiseOrValue<BigNumberish>;
        prizePeriodSeconds: PromiseOrValue<BigNumberish>;
        ticketName: PromiseOrValue<string>;
        ticketSymbol: PromiseOrValue<string>;
        sponsorshipName: PromiseOrValue<string>;
        sponsorshipSymbol: PromiseOrValue<string>;
        ticketCreditLimitMantissa: PromiseOrValue<BigNumberish>;
        ticketCreditRateMantissa: PromiseOrValue<BigNumberish>;
        numberOfWinners: PromiseOrValue<BigNumberish>;
        prizeSplits: PrizeSplit.PrizeSplitConfigStruct[];
        splitExternalErc20Awards: PromiseOrValue<boolean>;
    };
    type MultipleWinnersConfigStructOutput = [
        string,
        BigNumber,
        BigNumber,
        string,
        string,
        string,
        string,
        BigNumber,
        BigNumber,
        BigNumber,
        PrizeSplit.PrizeSplitConfigStructOutput[],
        boolean
    ] & {
        rngService: string;
        prizePeriodStart: BigNumber;
        prizePeriodSeconds: BigNumber;
        ticketName: string;
        ticketSymbol: string;
        sponsorshipName: string;
        sponsorshipSymbol: string;
        ticketCreditLimitMantissa: BigNumber;
        ticketCreditRateMantissa: BigNumber;
        numberOfWinners: BigNumber;
        prizeSplits: PrizeSplit.PrizeSplitConfigStructOutput[];
        splitExternalErc20Awards: boolean;
    };
}
export interface PoolTogetherV3PoolWithMultipleWinnersBuilderInterface extends utils.Interface {
    functions: {
        'compoundPrizePoolProxyFactory()': FunctionFragment;
        'createCompoundMultipleWinners((address,uint256),(address,uint256,uint256,string,string,string,string,uint256,uint256,uint256,(address,uint16,uint8)[],bool),uint8)': FunctionFragment;
        'createStakeMultipleWinners((address,uint256),(address,uint256,uint256,string,string,string,string,uint256,uint256,uint256,(address,uint16,uint8)[],bool),uint8)': FunctionFragment;
        'createYieldSourceMultipleWinners((address,uint256),(address,uint256,uint256,string,string,string,string,uint256,uint256,uint256,(address,uint16,uint8)[],bool),uint8)': FunctionFragment;
        'multipleWinnersBuilder()': FunctionFragment;
        'reserveRegistry()': FunctionFragment;
        'stakePrizePoolProxyFactory()': FunctionFragment;
        'yieldSourcePrizePoolProxyFactory()': FunctionFragment;
    };
    getFunction(nameOrSignatureOrTopic: 'compoundPrizePoolProxyFactory' | 'createCompoundMultipleWinners' | 'createStakeMultipleWinners' | 'createYieldSourceMultipleWinners' | 'multipleWinnersBuilder' | 'reserveRegistry' | 'stakePrizePoolProxyFactory' | 'yieldSourcePrizePoolProxyFactory'): FunctionFragment;
    encodeFunctionData(functionFragment: 'compoundPrizePoolProxyFactory', values?: undefined): string;
    encodeFunctionData(functionFragment: 'createCompoundMultipleWinners', values: [
        PoolWithMultipleWinnersBuilder.CompoundPrizePoolConfigStruct,
        MultipleWinnersBuilder.MultipleWinnersConfigStruct,
        PromiseOrValue<BigNumberish>
    ]): string;
    encodeFunctionData(functionFragment: 'createStakeMultipleWinners', values: [
        PoolWithMultipleWinnersBuilder.StakePrizePoolConfigStruct,
        MultipleWinnersBuilder.MultipleWinnersConfigStruct,
        PromiseOrValue<BigNumberish>
    ]): string;
    encodeFunctionData(functionFragment: 'createYieldSourceMultipleWinners', values: [
        PoolWithMultipleWinnersBuilder.YieldSourcePrizePoolConfigStruct,
        MultipleWinnersBuilder.MultipleWinnersConfigStruct,
        PromiseOrValue<BigNumberish>
    ]): string;
    encodeFunctionData(functionFragment: 'multipleWinnersBuilder', values?: undefined): string;
    encodeFunctionData(functionFragment: 'reserveRegistry', values?: undefined): string;
    encodeFunctionData(functionFragment: 'stakePrizePoolProxyFactory', values?: undefined): string;
    encodeFunctionData(functionFragment: 'yieldSourcePrizePoolProxyFactory', values?: undefined): string;
    decodeFunctionResult(functionFragment: 'compoundPrizePoolProxyFactory', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'createCompoundMultipleWinners', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'createStakeMultipleWinners', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'createYieldSourceMultipleWinners', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'multipleWinnersBuilder', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'reserveRegistry', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'stakePrizePoolProxyFactory', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'yieldSourcePrizePoolProxyFactory', data: BytesLike): Result;
    events: {
        'CompoundPrizePoolWithMultipleWinnersCreated(address,address)': EventFragment;
        'StakePrizePoolWithMultipleWinnersCreated(address,address)': EventFragment;
        'YieldSourcePrizePoolWithMultipleWinnersCreated(address,address)': EventFragment;
    };
    getEvent(nameOrSignatureOrTopic: 'CompoundPrizePoolWithMultipleWinnersCreated'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'StakePrizePoolWithMultipleWinnersCreated'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'YieldSourcePrizePoolWithMultipleWinnersCreated'): EventFragment;
}
export interface CompoundPrizePoolWithMultipleWinnersCreatedEventObject {
    prizePool: string;
    prizeStrategy: string;
}
export declare type CompoundPrizePoolWithMultipleWinnersCreatedEvent = TypedEvent<[
    string,
    string
], CompoundPrizePoolWithMultipleWinnersCreatedEventObject>;
export declare type CompoundPrizePoolWithMultipleWinnersCreatedEventFilter = TypedEventFilter<CompoundPrizePoolWithMultipleWinnersCreatedEvent>;
export interface StakePrizePoolWithMultipleWinnersCreatedEventObject {
    prizePool: string;
    prizeStrategy: string;
}
export declare type StakePrizePoolWithMultipleWinnersCreatedEvent = TypedEvent<[
    string,
    string
], StakePrizePoolWithMultipleWinnersCreatedEventObject>;
export declare type StakePrizePoolWithMultipleWinnersCreatedEventFilter = TypedEventFilter<StakePrizePoolWithMultipleWinnersCreatedEvent>;
export interface YieldSourcePrizePoolWithMultipleWinnersCreatedEventObject {
    prizePool: string;
    prizeStrategy: string;
}
export declare type YieldSourcePrizePoolWithMultipleWinnersCreatedEvent = TypedEvent<[
    string,
    string
], YieldSourcePrizePoolWithMultipleWinnersCreatedEventObject>;
export declare type YieldSourcePrizePoolWithMultipleWinnersCreatedEventFilter = TypedEventFilter<YieldSourcePrizePoolWithMultipleWinnersCreatedEvent>;
export interface PoolTogetherV3PoolWithMultipleWinnersBuilder extends BaseContract {
    connect(signerOrProvider: Signer | Provider | string): this;
    attach(addressOrName: string): this;
    deployed(): Promise<this>;
    interface: PoolTogetherV3PoolWithMultipleWinnersBuilderInterface;
    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: {
        compoundPrizePoolProxyFactory(overrides?: CallOverrides): Promise<[string]>;
        createCompoundMultipleWinners(prizePoolConfig: PoolWithMultipleWinnersBuilder.CompoundPrizePoolConfigStruct, prizeStrategyConfig: MultipleWinnersBuilder.MultipleWinnersConfigStruct, decimals: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        createStakeMultipleWinners(prizePoolConfig: PoolWithMultipleWinnersBuilder.StakePrizePoolConfigStruct, prizeStrategyConfig: MultipleWinnersBuilder.MultipleWinnersConfigStruct, decimals: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        createYieldSourceMultipleWinners(prizePoolConfig: PoolWithMultipleWinnersBuilder.YieldSourcePrizePoolConfigStruct, prizeStrategyConfig: MultipleWinnersBuilder.MultipleWinnersConfigStruct, decimals: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        multipleWinnersBuilder(overrides?: CallOverrides): Promise<[string]>;
        reserveRegistry(overrides?: CallOverrides): Promise<[string]>;
        stakePrizePoolProxyFactory(overrides?: CallOverrides): Promise<[string]>;
        yieldSourcePrizePoolProxyFactory(overrides?: CallOverrides): Promise<[string]>;
    };
    compoundPrizePoolProxyFactory(overrides?: CallOverrides): Promise<string>;
    createCompoundMultipleWinners(prizePoolConfig: PoolWithMultipleWinnersBuilder.CompoundPrizePoolConfigStruct, prizeStrategyConfig: MultipleWinnersBuilder.MultipleWinnersConfigStruct, decimals: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    createStakeMultipleWinners(prizePoolConfig: PoolWithMultipleWinnersBuilder.StakePrizePoolConfigStruct, prizeStrategyConfig: MultipleWinnersBuilder.MultipleWinnersConfigStruct, decimals: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    createYieldSourceMultipleWinners(prizePoolConfig: PoolWithMultipleWinnersBuilder.YieldSourcePrizePoolConfigStruct, prizeStrategyConfig: MultipleWinnersBuilder.MultipleWinnersConfigStruct, decimals: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    multipleWinnersBuilder(overrides?: CallOverrides): Promise<string>;
    reserveRegistry(overrides?: CallOverrides): Promise<string>;
    stakePrizePoolProxyFactory(overrides?: CallOverrides): Promise<string>;
    yieldSourcePrizePoolProxyFactory(overrides?: CallOverrides): Promise<string>;
    callStatic: {
        compoundPrizePoolProxyFactory(overrides?: CallOverrides): Promise<string>;
        createCompoundMultipleWinners(prizePoolConfig: PoolWithMultipleWinnersBuilder.CompoundPrizePoolConfigStruct, prizeStrategyConfig: MultipleWinnersBuilder.MultipleWinnersConfigStruct, decimals: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
        createStakeMultipleWinners(prizePoolConfig: PoolWithMultipleWinnersBuilder.StakePrizePoolConfigStruct, prizeStrategyConfig: MultipleWinnersBuilder.MultipleWinnersConfigStruct, decimals: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
        createYieldSourceMultipleWinners(prizePoolConfig: PoolWithMultipleWinnersBuilder.YieldSourcePrizePoolConfigStruct, prizeStrategyConfig: MultipleWinnersBuilder.MultipleWinnersConfigStruct, decimals: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
        multipleWinnersBuilder(overrides?: CallOverrides): Promise<string>;
        reserveRegistry(overrides?: CallOverrides): Promise<string>;
        stakePrizePoolProxyFactory(overrides?: CallOverrides): Promise<string>;
        yieldSourcePrizePoolProxyFactory(overrides?: CallOverrides): Promise<string>;
    };
    filters: {
        'CompoundPrizePoolWithMultipleWinnersCreated(address,address)'(prizePool?: PromiseOrValue<string> | null, prizeStrategy?: PromiseOrValue<string> | null): CompoundPrizePoolWithMultipleWinnersCreatedEventFilter;
        CompoundPrizePoolWithMultipleWinnersCreated(prizePool?: PromiseOrValue<string> | null, prizeStrategy?: PromiseOrValue<string> | null): CompoundPrizePoolWithMultipleWinnersCreatedEventFilter;
        'StakePrizePoolWithMultipleWinnersCreated(address,address)'(prizePool?: PromiseOrValue<string> | null, prizeStrategy?: PromiseOrValue<string> | null): StakePrizePoolWithMultipleWinnersCreatedEventFilter;
        StakePrizePoolWithMultipleWinnersCreated(prizePool?: PromiseOrValue<string> | null, prizeStrategy?: PromiseOrValue<string> | null): StakePrizePoolWithMultipleWinnersCreatedEventFilter;
        'YieldSourcePrizePoolWithMultipleWinnersCreated(address,address)'(prizePool?: PromiseOrValue<string> | null, prizeStrategy?: PromiseOrValue<string> | null): YieldSourcePrizePoolWithMultipleWinnersCreatedEventFilter;
        YieldSourcePrizePoolWithMultipleWinnersCreated(prizePool?: PromiseOrValue<string> | null, prizeStrategy?: PromiseOrValue<string> | null): YieldSourcePrizePoolWithMultipleWinnersCreatedEventFilter;
    };
    estimateGas: {
        compoundPrizePoolProxyFactory(overrides?: CallOverrides): Promise<BigNumber>;
        createCompoundMultipleWinners(prizePoolConfig: PoolWithMultipleWinnersBuilder.CompoundPrizePoolConfigStruct, prizeStrategyConfig: MultipleWinnersBuilder.MultipleWinnersConfigStruct, decimals: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        createStakeMultipleWinners(prizePoolConfig: PoolWithMultipleWinnersBuilder.StakePrizePoolConfigStruct, prizeStrategyConfig: MultipleWinnersBuilder.MultipleWinnersConfigStruct, decimals: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        createYieldSourceMultipleWinners(prizePoolConfig: PoolWithMultipleWinnersBuilder.YieldSourcePrizePoolConfigStruct, prizeStrategyConfig: MultipleWinnersBuilder.MultipleWinnersConfigStruct, decimals: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        multipleWinnersBuilder(overrides?: CallOverrides): Promise<BigNumber>;
        reserveRegistry(overrides?: CallOverrides): Promise<BigNumber>;
        stakePrizePoolProxyFactory(overrides?: CallOverrides): Promise<BigNumber>;
        yieldSourcePrizePoolProxyFactory(overrides?: CallOverrides): Promise<BigNumber>;
    };
    populateTransaction: {
        compoundPrizePoolProxyFactory(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        createCompoundMultipleWinners(prizePoolConfig: PoolWithMultipleWinnersBuilder.CompoundPrizePoolConfigStruct, prizeStrategyConfig: MultipleWinnersBuilder.MultipleWinnersConfigStruct, decimals: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        createStakeMultipleWinners(prizePoolConfig: PoolWithMultipleWinnersBuilder.StakePrizePoolConfigStruct, prizeStrategyConfig: MultipleWinnersBuilder.MultipleWinnersConfigStruct, decimals: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        createYieldSourceMultipleWinners(prizePoolConfig: PoolWithMultipleWinnersBuilder.YieldSourcePrizePoolConfigStruct, prizeStrategyConfig: MultipleWinnersBuilder.MultipleWinnersConfigStruct, decimals: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        multipleWinnersBuilder(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        reserveRegistry(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        stakePrizePoolProxyFactory(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        yieldSourcePrizePoolProxyFactory(overrides?: CallOverrides): Promise<PopulatedTransaction>;
    };
}
