import { QualifyGroup, Round } from '../qualify/group';
import { Competition } from '../competition';
import { Place } from '../place';
import { Poule } from '../poule';
import { RoundNumber } from '../round/number';
import { Structure } from '../structure';
import { VoetbalRange } from '../range';
import { JsonPlanningConfig } from '../planning/config/json';
import { QualifyTarget } from '../qualify/target';
import { BalancedPouleStructure } from '../poule/structure/balanced';
import { PlanningConfigMapper } from '../planning/config/mapper';
import { PlaceRanges } from './placeRanges';
import { Category } from '../category';
import { QualifyDistribution } from '../qualify/distribution';
import { HorizontalSingleQualifyRule } from '../qualify/rule/horizontal/single';
import { CompetitionSportEditor } from '../competition/sport/editor';
import { VerticalSingleQualifyRule } from '../qualify/rule/vertical/single';
import * as i0 from "@angular/core";
export declare class StructureEditor {
    private competitionSportEditor;
    private planningConfigMapper;
    private horPouleCreator;
    private rulesCreator;
    private removalValidator;
    private placeRanges;
    constructor(competitionSportEditor: CompetitionSportEditor, planningConfigMapper: PlanningConfigMapper);
    setPlaceRanges(placeRanges: PlaceRanges): void;
    create(competition: Competition, pouleStructure: number[], jsonPlanningConfig?: JsonPlanningConfig | undefined, categoryName?: string | undefined): Structure;
    addCategory(name: string, abbreviation: string | undefined, number: number, firstRoundNumber: RoundNumber, pouleStructure: BalancedPouleStructure): Category;
    addCategoryHelper(name: string, abbreviation: string | undefined, number: number, firstRoundNumber: RoundNumber, pouleStructure: BalancedPouleStructure): Category;
    switchCategories(structure: Structure, activeCategory: Category, forcedCategory: Category): void;
    private switchInArray;
    addChildRound(parentRound: Round, qualifyTarget: QualifyTarget, pouleStructure: number[], distribution?: QualifyDistribution): Round;
    private addChildRoundHelper;
    /**
     * voor een ronde kun je:
     * A een plek toevoegen(in rootround, of in een volgende ronde, via addqualifier) KAN GEEN INVLOED HEBBEN OP HET AANTAL QUALIFYGROUPS
     * B een plek verwijderen(in rootround, of in een volgende ronde, via removequalifier)
     * C het aantal poules verkleinen met 1     - refillRound, update horpoules and update previousround qualifyrules
     * D C het aantal poules vergroten met 1    - refillRound, update horpoules and update previousround qualifyrules
     *
     * C, D hebben geen invloed op het aantal plekken in volgende ronden
     */
    addPlaceToRootRound(rootRound: Round): Place;
    removePlaceFromRootRound(rootRound: Round): void;
    addPouleToRootRound(rootRound: Round): Poule;
    removePouleFromRootRound(rootRound: Round): void;
    private removeChildRoundPlaces;
    incrementNrOfPoules(round: Round): void;
    decrementNrOfPoules(round: Round): void;
    updateDistribution(qualifyGroup: QualifyGroup, distribution: QualifyDistribution): void;
    addQualifiers(parentRound: Round, qualifyTarget: QualifyTarget, nrOfToPlacesToAdd: number, distribution: QualifyDistribution, maxNrOfPoulePlaces?: number): void;
    protected canAddPouleByAddingOnePlace(pouleStructure: BalancedPouleStructure, maxNrOfPoulePlaces: number): boolean;
    removeQualifier(parentRound: Round, qualifyTarget: QualifyTarget): boolean;
    private fillRound;
    protected getNrOfQualifiersPrevious(singleRule: HorizontalSingleQualifyRule | VerticalSingleQualifyRule): number;
    protected getNrOfQualifiersNext(singleRule: HorizontalSingleQualifyRule | VerticalSingleQualifyRule): number;
    protected getRoot(round: Round): Round;
    createBalanced(nrOfPlaces: number, nrOfPoules: number): BalancedPouleStructure;
    isQualifyGroupSplittableAt(singleRule: HorizontalSingleQualifyRule | VerticalSingleQualifyRule): boolean;
    /**
* 1 : wanneer er een kw.groep van minimaal 2 horizontale poules is (grens h poule  moet minimaal twee door laten gaan)
* 2 : 2 kw.groepen van winners of losers.
*/
    isSomeQualifyGroupEditable(parentRound: Round, target: QualifyTarget): boolean;
    isSomeQualifyGroupSplittable(parentRound: Round, target: QualifyTarget): boolean;
    isSomeQualifyGroupMergable(parentRound: Round, target: QualifyTarget): boolean;
    hasSomeQualifyGroupASingleRule(parentRound: Round, target: QualifyTarget): boolean;
    isQualifyGroupSplittable(qualifyGroup: QualifyGroup): boolean;
    splitQualifyGroupFrom(qualifyGroup: QualifyGroup, singleRule: HorizontalSingleQualifyRule | VerticalSingleQualifyRule): void;
    protected insertAfterQualifyGroup(parentRound: Round, qualifyGroup: QualifyGroup): QualifyGroup;
    protected calculateNrOfPoulesInsertedQualifyGroup(nrOfToPlaces: number, nrOfPoulePlaces: number): number;
    /**
     * recalc horPoules and rules only downwards
     */
    protected removePlaceFromRound(round: Round, canHaveZeroDropoutPlaces?: boolean): void;
    areQualifyGroupsMergable(previous: QualifyGroup, current: QualifyGroup): boolean;
    mergeQualifyGroups(firstQualifyGroup: QualifyGroup, secondQualifyGroup: QualifyGroup): void;
    protected renumber(round: Round, qualifyTarget: QualifyTarget): void;
    validate(competition: Competition, nrOfPlaces: number, nrOfPoules: number): void;
    getMinPlacesPerPouleSmall(): number;
    private addChildRoundPlacesForNonCrossFinals;
    static ɵfac: i0.ɵɵFactoryDeclaration<StructureEditor, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StructureEditor>;
}
export interface PlaceRange extends VoetbalRange {
    placesPerPoule: VoetbalRange;
}
export declare enum ExpandDirection {
    Horizontal = 0,
    Vertical = 1
}