import { RoundNumber } from '../round/number';
import { HorizontalPoule } from '../poule/horizontal';
import { Competition } from '../competition';
import { Place } from '../place';
import { PlaceLocation } from '../place/location';
import { Poule } from '../poule';
import { CompetitionSport } from '../competition/sport';
import { ScoreConfig } from '../score/config';
import { AgainstQualifyConfig } from './againstConfig';
import { Identifiable } from '../identifiable';
import { AgainstGame } from '../game/against';
import { TogetherGame } from '../game/together';
import { QualifyTarget } from './target';
import { QualifyPathNode } from './pathNode';
import { BalancedPouleStructure } from '../poule/structure/balanced';
import { GameState } from '../game/state';
import { Category } from '../category';
import { StructureCell } from '../structure/cell';
import { StartLocation } from '../competitor/startLocation';
import { QualifyDistribution } from './distribution';
import { VerticalMultipleQualifyRule } from './rule/vertical/multiple';
import { VerticalSingleQualifyRule } from './rule/vertical/single';
import { HorizontalSingleQualifyRule } from './rule/horizontal/single';
import { HorizontalMultipleQualifyRule } from './rule/horizontal/multiple';
import { NrOfDropOuts } from '../ranking/calculator/end';
export declare class QualifyGroup extends Identifiable {
    protected parentRound: Round;
    protected target: QualifyTarget;
    static readonly QUALIFYORDER_CROSS = 1;
    static readonly QUALIFYORDER_RANK = 2;
    static readonly QUALIFYORDER_CUSTOM1 = 4;
    static readonly QUALIFYORDER_CUSTOM2 = 5;
    protected number: number;
    protected childRound: Round;
    protected distribution: QualifyDistribution;
    protected firstSingleRule: HorizontalSingleQualifyRule | VerticalSingleQualifyRule | undefined;
    protected multipleRule: HorizontalMultipleQualifyRule | VerticalMultipleQualifyRule | undefined;
    constructor(parentRound: Round, target: QualifyTarget, nextStructureCell: StructureCell, number?: number);
    getParentRound(): Round;
    getTarget(): QualifyTarget;
    getNumber(): number;
    setNumber(number: number): void;
    getChildRound(): Round;
    getDistribution(): QualifyDistribution;
    setDistribution(distribution: QualifyDistribution): void;
    getFirstSingleRule(): HorizontalSingleQualifyRule | VerticalSingleQualifyRule | undefined;
    setFirstSingleRule(singleRule: HorizontalSingleQualifyRule | VerticalSingleQualifyRule | undefined): void;
    getMultipleRule(): HorizontalMultipleQualifyRule | VerticalMultipleQualifyRule | undefined;
    setMultipleRule(multipleRule: HorizontalMultipleQualifyRule | VerticalMultipleQualifyRule | undefined): void;
    getNrOfSingleRules(): number;
    getRulesNrOfToPlaces(): number;
    getNext(): QualifyGroup | undefined;
    getRuleByToPlace(toPlace: Place): HorizontalSingleQualifyRule | HorizontalMultipleQualifyRule | VerticalSingleQualifyRule | VerticalMultipleQualifyRule;
    getFromPlace(toPlace: Place): Place | undefined;
    isBorderGroup(): boolean;
    detach(): void;
    detachRules(): void;
}
export declare class Round extends Identifiable {
    protected structureCell: StructureCell;
    protected parentQualifyGroup: QualifyGroup | undefined;
    static readonly ORDER_NUMBER_POULE = 1;
    static readonly ORDER_POULE_NUMBER = 2;
    protected name: string | undefined;
    protected poules: Poule[];
    protected losersQualifyGroups: QualifyGroup[];
    protected winnersQualifyGroups: QualifyGroup[];
    protected losersHorizontalPoules: HorizontalPoule[];
    protected winnersHorizontalPoules: HorizontalPoule[];
    protected qualifyPathNode: QualifyPathNode;
    protected scoreConfigs: ScoreConfig[];
    protected againstQualifyConfigs: AgainstQualifyConfig[];
    constructor(structureCell: StructureCell, parentQualifyGroup: QualifyGroup | undefined);
    getCompetition(): Competition;
    getCategory(): Category;
    getParent(): Round | undefined;
    getParentQualifyGroup(): QualifyGroup | undefined;
    getStructureCell(): StructureCell;
    getNumber(): RoundNumber;
    getNumberAsValue(): number;
    getNrOfDropoutPlaces(): NrOfDropOuts;
    getQualifyGroups(qualifyTarget?: QualifyTarget): QualifyGroup[];
    getQualifyGroupsLosersReversed(): QualifyGroup[];
    getQualifyGroup(qualifyTarget: QualifyTarget, qualifyGroupNumber: number): QualifyGroup | undefined;
    getBorderQualifyGroup(qualifyTarget: QualifyTarget): QualifyGroup;
    getChildren(): Round[];
    getChild(qualifyTarget: QualifyTarget, qualifyGroupNumber: number): Round | undefined;
    getRoot(): Round;
    isRoot(): boolean;
    getName(): string | undefined;
    setName(name: string): void;
    getPoules(): Poule[];
    getPoule(number: number): Poule;
    getHorizontalPoules(qualifyTarget: QualifyTarget): HorizontalPoule[];
    getHorizontalPoule(qualifyTarget: QualifyTarget, number: number): HorizontalPoule;
    getFirstPlace(qualifyTarget: QualifyTarget): Place;
    getPlaces(order?: number): Place[];
    getPlace(placeLocation: PlaceLocation): Place;
    getGames(): (AgainstGame | TogetherGame)[];
    getNrOfGames(): number;
    getGamesState(): GameState;
    hasBegun(): boolean;
    hasFinished(): boolean;
    needsRanking(): boolean;
    getNrOfPlaces(): number;
    getNrOfPlacesChildren(qualifyTarget?: QualifyTarget): number;
    getScoreConfigs(): ScoreConfig[];
    getScoreConfig(competitionSport: CompetitionSport): ScoreConfig | undefined;
    getValidScoreConfigs(): ScoreConfig[];
    getValidScoreConfig(competitionSport: CompetitionSport): ScoreConfig;
    getAgainstQualifyConfigs(): AgainstQualifyConfig[];
    getAgainstQualifyConfig(competitionSport: CompetitionSport): AgainstQualifyConfig | undefined;
    setAgainstQualifyConfig(qualifyagainstConfig: AgainstQualifyConfig): void;
    getValidAgainstQualifyConfigs(): AgainstQualifyConfig[];
    getValidAgainstQualifyConfig(competitionSport: CompetitionSport): AgainstQualifyConfig;
    hasAncestor(ancestor: Round): boolean;
    addPlace(): void;
    removePlace(): number;
    getFirstPoule(): Poule;
    getLastPoule(): Poule;
    addPoule(): Poule;
    removePoule(): Poule;
    protected constructQualifyPathNode(): QualifyPathNode;
    getPathNode(): QualifyPathNode;
    createPouleStructure(): BalancedPouleStructure;
    detach(): void;
    hasQualified(startLocation: StartLocation): boolean;
}