/// <reference types="bn.js" />
/// <reference types="node" />
import { BN, BigNum, DataAndSlot, Event, EventSubscriptionOrderBy, EventSubscriptionOrderDirection, LogProviderConfig } from '@drift-labs/sdk';
import { Commitment, PublicKey, TransactionSignature } from '@solana/web3.js';
import { EventEmitter } from 'events';
import StrictEventEmitter from 'strict-event-emitter-types';
export type SponsorInfo = {
    sponsor: PublicKey;
    minSponsorAmount: BN;
    maxSponsorFraction: BN;
};
export type SortFn = (currentRecord: CompetitionsEventMap[EventType], newRecord: CompetitionsEventMap[EventType]) => 'less than' | 'greater than';
export declare class CompetitionStatus {
    static readonly ACTIVE: {
        active: {};
    };
    static readonly WINNER_AND_PRIZE_RANDOMNESS_REQUESTED: {
        winnerAndPrizeRandomnessRequested: {};
    };
    static readonly WINNER_AND_PRIZE_RANDOMNESS_COMPLETE: {
        WinnerAndPrizeRandomnessComplete: {};
    };
    static readonly WINNER_SETTLEMENT_COMPLETE: {
        WinnerSettlementComplete: {};
    };
    static readonly EXPIRED: {
        Expired: {};
    };
}
export declare class CompetitorStatus {
    static readonly ACTIVE: {
        active: {};
    };
    static readonly DISQUALIFIED: {
        disqualified: {};
    };
}
export type EventSubscriptionOptions = {
    address?: PublicKey;
    eventTypes?: EventType[];
    maxEventsPerType?: number;
    orderBy?: EventSubscriptionOrderBy;
    orderDir?: EventSubscriptionOrderDirection;
    commitment?: Commitment;
    maxTx?: number;
    logProviderConfig?: LogProviderConfig;
    untilTx?: TransactionSignature;
};
export declare const DefaultEventSubscriptionOptions: EventSubscriptionOptions;
export type Competition = {
    name: number[];
    sponsorInfo: SponsorInfo;
    switchboardFunction: PublicKey;
    switchboardFunctionRequest: PublicKey;
    switchboardFunctionRequestEscrow: PublicKey;
    competitionAuthority: PublicKey;
    numberOfCompetitors: BN;
    numberOfCompetitorsSettled: BN;
    totalScoreSettled: BN;
    maxEntriesPerCompetitor: BN;
    prizeAmount: BN;
    prizeBase: BN;
    winnerRandomness: BN;
    prizeRandomness: BN;
    prizeRandomnessMax: BN;
    outstandingUnclaimedWinnings: BN;
    roundNumber: BN;
    nextRoundExpiryTs: BN;
    competitionExpiryTs: BN;
    roundDuration: BN;
    status: CompetitionStatus;
    competitionAuthorityBump: number;
};
export type Competitor = {
    authority: PublicKey;
    competition: PublicKey;
    userStats: PublicKey;
    minDraw: BN;
    maxDraw: BN;
    unclaimedWinningsBase: BN;
    unclaimedWinnings: BN;
    competitionRoundNumber: BN;
    previousSnapshotScore: BN;
    latestSnapshotScore: BN;
    bonusScore: BN;
    status: CompetitorStatus;
};
/** Events */
export type DriftCompetitionsProgramAccountBaseEvents = {
    update: void;
    error: (e: Error) => void;
};
export type CompetitionAccountEvents = DriftCompetitionsProgramAccountBaseEvents & {
    competitionUpdate: (competition: Competition) => void;
};
export type CompetitorAccountEvents = DriftCompetitionsProgramAccountBaseEvents & {
    competitorUpdate: (competitor: Competitor) => void;
};
export type CompetitionRoundSummaryRecord = {
    competition: PublicKey;
    roundNumber: BN;
    roundStartTs: BN;
    roundEndTs: BN;
    prizePlacement: BN;
    prizeOddsNumerator: BN;
    prizeRandomness: BN;
    prizeRandomnessMax: BN;
    maxPrizeBucketValue: BN;
    prizeAmount: BN;
    prizeValue: BN;
    prizeBase: BN;
    numberOfWinners: BN;
    numberOfCompetitorsSettled: BN;
    totalScoreSettled: BN;
    insuranceVaultBalance: BN;
    protocolIfShares: BN;
    totalIfShares: BN;
    ts: BN;
};
export type CompetitionRoundWinnerRecord = {
    roundNumber: BN;
    competitor: PublicKey;
    competition: PublicKey;
    competitorAuthority: PublicKey;
    minDraw: BN;
    maxDraw: BN;
    winnerPlacement: number;
    numberOfWinners: number;
    numberOfCompetitorsSettled: BN;
    winnerRandomness: BN;
    totalScoreSettled: BN;
    prizeRandomness: BN;
    prizeRandomnessMax: BN;
    prizeAmount: BN;
    prizeBase: BN;
    prizeValue: BN;
    ts: BN;
};
export type CompetitorSettledRecord = {
    roundNumber: BN;
    competitor: PublicKey;
    competition: PublicKey;
    competitorAuthority: PublicKey;
    status: CompetitorStatus;
    unclaimedWinnings: BN;
    minDraw: BN;
    maxDraw: BN;
    bonusScoreBefore: BN;
    bonusScoreAfter: BN;
    previousSnapshotScoreBefore: BN;
    snapshotScore: BN;
    ts: BN;
};
export type CompetitionsEventMap = {
    CompetitionRoundWinnerRecord: Event<CompetitionRoundWinnerRecord>;
    CompetitionRoundSummaryRecord: Event<CompetitionRoundSummaryRecord>;
    CompetitorSettledRecord: Event<CompetitorSettledRecord>;
};
export type EventType = keyof CompetitionsEventMap;
export type WrappedEvent<Type extends EventType> = CompetitionsEventMap[Type] & {
    eventType: Type;
};
export type WrappedEvents = WrappedEvent<EventType>[];
export type DriftSweepstakesEvent = CompetitionsEventMap['CompetitionRoundSummaryRecord'] | CompetitionsEventMap['CompetitionRoundWinnerRecord'] | CompetitionsEventMap['CompetitorSettledRecord'];
export interface EventSubscriberEvents {
    newEvent: (event: WrappedEvent<EventType>) => void;
}
/** Account Subscribers */
export interface DriftCompetitionsProgramAccountSubscriber<Account, AccountEvents extends DriftCompetitionsProgramAccountBaseEvents> {
    eventEmitter: StrictEventEmitter<EventEmitter, AccountEvents>;
    isSubscribed: boolean;
    subscribe(): Promise<boolean>;
    fetch(): Promise<void>;
    updateData(account: Account, slot: number): void;
    unsubscribe(): Promise<void>;
    getAccountAndSlot(): DataAndSlot<Account>;
}
export type CompetitionAccountSubscriber = DriftCompetitionsProgramAccountSubscriber<Competition, CompetitionAccountEvents>;
export type CompetitorAccountSubscriber = DriftCompetitionsProgramAccountSubscriber<Competitor, CompetitorAccountEvents>;
export type CompetitionResult = {
    startTs: number;
    endTs: number;
    roundNumber: number;
    competitors: BN;
    totalTickets: BN;
    summaryEvent: Event<CompetitionRoundSummaryRecord>;
    winners: {
        authority: PublicKey;
        prize: BigNum;
        tickets: BN;
        placement: number;
        winnerEvent: Event<CompetitionRoundWinnerRecord>;
    }[];
};
export type LiveCompetitionInfo = {
    lastFetchedTs: number;
    roundNumber: number;
    endTs: number;
    totalCompetitors: number;
    totalTickets: BN;
    topCompetitors: {
        authority: PublicKey;
        ticketCount: BN;
    }[];
};