volleyballsimtypes 0.0.138 → 0.0.140

package/dist/esm/data/transformers/role.js

@@ -0,0 +1,23 @@
+import { Role } from '../../service';
+function transformToType(role) {
+    switch (role) {
+        case Role.SETTER:
+            return 'SETTER';
+        case Role.DEFENSIVE_SPECIALIST:
+            return 'DEFENSIVE_SPECIALIST';
+        case Role.LIBERO:
+            return 'LIBERO';
+        case Role.MIDDLE_BLOCKER:
+            return 'MIDDLE_BLOCKER';
+        case Role.OUTSIDE_HITTER:
+            return 'OUTSIDE_HITTER';
+        case Role.OPPOSITE_HITTER:
+            return 'OPPOSITE_HITTER';
+        default:
+            throw new Error('UNKNOWN_ROLE');
+    }
+}
+function transformFromType(role) {
+    return Role[role];
+}
+export { transformToType as transformFromRole, transformFromType as transformToRole };

package/dist/esm/data/transformers/season-match.d.ts

@@ -0,0 +1,4 @@
+import { CompetitionMatchAttributes } from '../models';
+import { Match } from '../../service';
+declare function transformToAttributes(seasonId: string, match: Match, index: number): CompetitionMatchAttributes;
+export { transformToAttributes as transformFromSeasonMatch };

package/dist/esm/data/transformers/season-match.js

@@ -0,0 +1,13 @@
+import { Stage } from '../../service';
+import { transformFromMatch } from './match';
+import { transformFromStage } from './stage';
+function transformToAttributes(seasonId, match, index) {
+    return {
+        competition_id: seasonId,
+        match_id: match.id,
+        index,
+        stage: transformFromStage(Stage.LEAGUE),
+        Match: transformFromMatch(match)
+    };
+}
+export { transformToAttributes as transformFromSeasonMatch };

package/dist/esm/data/transformers/season.d.ts

@@ -0,0 +1,5 @@
+import { CompetitionAttributes, CompetitionModel } from '../models';
+import { Season } from '../../service';
+declare function transformToAttributes(season: Season, leagueId: string): CompetitionAttributes;
+declare function transformToObject(model: CompetitionModel): Season;
+export { transformToObject as transformToSeason, transformToAttributes as transformFromSeason };

package/dist/esm/data/transformers/season.js

@@ -0,0 +1,39 @@
+import { transformFromSeasonMatch, transformToIteration, transformToMatch, transformToTeam } from '.';
+import { Season } from '../../service';
+function transformToAttributes(season, leagueId) {
+    const matches = season.matches != null
+        ? season.matches.map((match, index) => transformFromSeasonMatch(season.id, match, index))
+        : [];
+    const teams = season.teams.map(team => ({
+        competition_id: season.id,
+        team_id: team.id
+    }));
+    const champion = season.champion != null
+        ? {
+            competition_id: season.id,
+            team_id: season.champion?.id
+        }
+        : undefined;
+    return {
+        competition_id: season.id,
+        type: 'LEAGUE',
+        iteration: season.iteration.id,
+        LeagueSeason: { league_id: leagueId, competition_id: season.id },
+        CompetitionChampion: champion,
+        CompetitionMatches: matches,
+        CompetitionTeams: teams
+    };
+}
+function transformToObject(model) {
+    const matches = model.CompetitionMatches == null
+        ? []
+        : model.CompetitionMatches.map((matches) => transformToMatch(matches.Match));
+    return new Season({
+        id: model.competition_id,
+        matches,
+        iteration: transformToIteration(model.Iteration),
+        teams: model.Teams != null ? model.Teams.map(transformToTeam) : [],
+        champion: model.CompetitionChampion != null ? transformToTeam(model.CompetitionChampion.team) : undefined
+    });
+}
+export { transformToObject as transformToSeason, transformToAttributes as transformFromSeason };

package/dist/esm/data/transformers/set-position.d.ts

@@ -0,0 +1,5 @@
+import { PlayerPosition } from '../../service';
+import { SetPositionAttributes, SetPositionModel } from '../models';
+declare function transformToAttributes(playerPosition: PlayerPosition, side: 'HOME' | 'AWAY', setId: string): SetPositionAttributes;
+declare function transformToObject(model: SetPositionModel): PlayerPosition;
+export { transformToObject as transformToPlayerPosition, transformToAttributes as transformFromPlayerPosition };

package/dist/esm/data/transformers/set-position.js

@@ -0,0 +1,16 @@
+import { transformFromCourtPosition, transformToCourtPosition } from '.';
+function transformToAttributes(playerPosition, side, setId) {
+    return {
+        match_set_id: setId,
+        side,
+        court_position: transformFromCourtPosition(playerPosition.position),
+        player_id: playerPosition.playerId
+    };
+}
+function transformToObject(model) {
+    return {
+        playerId: model.player_id,
+        position: transformToCourtPosition(model.court_position)
+    };
+}
+export { transformToObject as transformToPlayerPosition, transformToAttributes as transformFromPlayerPosition };

package/dist/esm/data/transformers/stage.d.ts

@@ -0,0 +1,5 @@
+import { Stage } from '../../service';
+import { CompetitionStage } from '../models';
+declare function transformToType(stage: Stage): CompetitionStage;
+declare function transformFromType(s: CompetitionStage): Stage;
+export { transformToType as transformFromStage, transformFromType as transformToStage };

package/dist/esm/data/transformers/stage.js

@@ -0,0 +1,21 @@
+import { Stage } from '../../service';
+function transformToType(stage) {
+    switch (stage) {
+        case Stage.ROUND_OF_8:
+            return 'ROUND_OF_8';
+        case Stage.QUARTERFINALS:
+            return 'QUARTERFINALS';
+        case Stage.SEMIFINALS:
+            return 'SEMIFINALS';
+        case Stage.FINAL:
+            return 'FINAL';
+        case Stage.LEAGUE:
+            return 'LEAGUE';
+        default:
+            throw new Error('UNKNOWN_ROLE');
+    }
+}
+function transformFromType(s) {
+    return Stage[s];
+}
+export { transformToType as transformFromStage, transformFromType as transformToStage };

package/dist/esm/data/transformers/team.d.ts

@@ -0,0 +1,5 @@
+import { Team } from '../../service';
+import { TeamAttributes, TeamModel } from '../models';
+declare function transformToAttributes(team: Team): TeamAttributes;
+declare function transformToObject(team: TeamModel): Team;
+export { transformToObject as transformToTeam, transformToAttributes as transformFromTeam };

package/dist/esm/data/transformers/team.js

@@ -0,0 +1,28 @@
+import { Team } from '../../service';
+import { transformFromCoach, transformToCoach, transformToCountry, transformToPlayer } from '.';
+function transformToAttributes(team) {
+    return {
+        team_id: team.id,
+        name: team.name,
+        short_name: team.shortName,
+        coach_id: team.coach != null ? team.coach.id : undefined,
+        country_id: team.country != null ? team.country.id : undefined,
+        league_id: team.league != null ? team.league.id : undefined,
+        coach: team.coach != null ? transformFromCoach(team.coach) : undefined,
+        rating: team.rating
+    };
+}
+function transformToObject(team) {
+    return new Team({
+        id: team.team_id,
+        name: team.name,
+        shortName: team.short_name,
+        country: team.country != null ? transformToCountry(team.country) : undefined,
+        coach: team.coach != null ? transformToCoach(team.coach) : undefined,
+        roster: team.PlayerTeams == null
+            ? []
+            : team.PlayerTeams.map((pt) => transformToPlayer(pt.player)),
+        rating: team.rating
+    });
+}
+export { transformToObject as transformToTeam, transformToAttributes as transformFromTeam };

package/dist/esm/data/transformers/tournament-match.d.ts

@@ -0,0 +1,5 @@
+import { TournamentMatch } from '../../service';
+import { CompetitionMatchAttributes, CompetitionMatchModel } from '../models';
+declare function transformToAttributes(tournamentMatch: TournamentMatch, tournamentId: string): CompetitionMatchAttributes;
+declare function transformToObject(model: CompetitionMatchModel): TournamentMatch;
+export { transformToObject as transformToTournamentMatch, transformToAttributes as transformFromTournamentMatch };

package/dist/esm/data/transformers/tournament-match.js

@@ -0,0 +1,19 @@
+import { TournamentMatch } from '../../service';
+import { transformFromMatch, transformFromStage, transformToMatch, transformToStage } from '.';
+function transformToAttributes(tournamentMatch, tournamentId) {
+    return {
+        competition_id: tournamentId,
+        match_id: tournamentMatch.match.id,
+        index: tournamentMatch.index,
+        stage: transformFromStage(tournamentMatch.stage),
+        Match: transformFromMatch(tournamentMatch.match)
+    };
+}
+function transformToObject(model) {
+    return new TournamentMatch({
+        stage: transformToStage(model.stage),
+        match: transformToMatch(model.Match),
+        index: model.index
+    });
+}
+export { transformToObject as transformToTournamentMatch, transformToAttributes as transformFromTournamentMatch };

package/dist/esm/data/transformers/tournament.d.ts

@@ -0,0 +1,5 @@
+import { CompetitionAttributes, CompetitionModel } from '../models';
+import { Tournament } from '../../service';
+declare function transformToAttributes(tournament: Tournament): CompetitionAttributes;
+declare function transformToObject(model: CompetitionModel): Tournament;
+export { transformToObject as transformToTournament, transformToAttributes as transformFromTournament };

package/dist/esm/data/transformers/tournament.js

@@ -0,0 +1,33 @@
+import { transformFromTournamentMatch, transformToIteration, transformToTeam, transformToTournamentMatch } from '.';
+import { Tournament } from '../../service';
+function transformToAttributes(tournament) {
+    const matches = tournament.matches.map((match) => transformFromTournamentMatch(match, tournament.id));
+    const teams = tournament.teams.map((team) => ({
+        competition_id: tournament.id,
+        team_id: team.id
+    }));
+    const champion = tournament.champion == null
+        ? undefined
+        : {
+            competition_id: tournament.id,
+            team_id: tournament.champion?.id
+        };
+    return {
+        competition_id: tournament.id,
+        type: 'TOURNAMENT',
+        iteration: tournament.iteration.id,
+        CompetitionChampion: champion,
+        CompetitionMatches: matches,
+        CompetitionTeams: teams
+    };
+}
+function transformToObject(model) {
+    return new Tournament({
+        id: model.competition_id,
+        iteration: transformToIteration(model.Iteration),
+        matches: model.CompetitionMatches != null ? model.CompetitionMatches.map(transformToTournamentMatch) : [],
+        teams: model.Teams != null ? model.Teams.map(transformToTeam) : [],
+        champion: model.CompetitionChampion != null ? transformToTeam(model.CompetitionChampion.team) : undefined
+    });
+}
+export { transformToObject as transformToTournament, transformToAttributes as transformFromTournament };

package/dist/esm/data/transformers/trait.d.ts

@@ -0,0 +1,5 @@
+import { Trait } from '../../service';
+import { TraitAttributes, TraitModel } from '../models';
+declare function transformToAttributes(trait: Trait): TraitAttributes;
+declare function transformToObject(model: TraitModel): Trait;
+export { transformToObject as transformToTrait, transformToAttributes as transformFromTrait };

package/dist/esm/data/transformers/trait.js

@@ -0,0 +1,15 @@
+import { Trait } from '../../service';
+function transformToAttributes(trait) {
+    return {
+        trait_id: trait.id,
+        name: trait.name
+    };
+}
+function transformToObject(model) {
+    const trait = Trait.getTraits().find((trait) => trait.id === model.trait_id);
+    if (trait == null) {
+        throw new Error('TRAIT_NOT_FOUND');
+    }
+    return trait;
+}
+export { transformToObject as transformToTrait, transformToAttributes as transformFromTrait };

package/dist/esm/index.d.ts

@@ -0,0 +1,2 @@
+export * from './service';
+export * from './data';

package/dist/esm/index.js

@@ -0,0 +1,2 @@
+export * from './service';
+export * from './data';

package/dist/esm/service/coach/coach.d.ts

@@ -0,0 +1,19 @@
+import { Formation } from './formation';
+import { Name } from '../player';
+import { Country } from '../country';
+interface CoachOpts {
+    readonly id: string;
+    readonly name: Name;
+    readonly country: Country;
+    readonly formation: Formation;
+    readonly substitutionTolerance: number;
+}
+export declare class Coach {
+    readonly id: string;
+    readonly name: Name;
+    readonly country: Country;
+    readonly formation: Formation;
+    readonly substitutionTolerance: number;
+    constructor({ id, name, country, formation, substitutionTolerance }: CoachOpts);
+}
+export {};

package/dist/esm/service/coach/coach.js

@@ -0,0 +1,11 @@
+import { validateUUID } from '../utils';
+export class Coach {
+    constructor({ id, name, country, formation, substitutionTolerance }) {
+        validateUUID(id);
+        this.id = id;
+        this.name = name;
+        this.country = country;
+        this.formation = formation;
+        this.substitutionTolerance = substitutionTolerance;
+    }
+}

package/dist/esm/service/coach/formation.d.ts

@@ -0,0 +1,31 @@
+import { Role } from '../player';
+import { CourtPosition } from '../match';
+interface PositionRole {
+    readonly [CourtPosition.LEFT_FRONT]: Role[];
+    readonly [CourtPosition.MIDDLE_FRONT]: Role[];
+    readonly [CourtPosition.RIGHT_FRONT]: Role[];
+    readonly [CourtPosition.LEFT_BACK]: Role[];
+    readonly [CourtPosition.MIDDLE_BACK]: Role[];
+    readonly [CourtPosition.RIGHT_BACK]: Role[];
+}
+export interface SubPriority {
+    readonly MIDDLE_BLOCKER: number;
+    readonly OUTSIDE_HITTER: number;
+    readonly OPPOSITE_HITTER: number;
+    readonly DEFENSIVE_SPECIALIST: number;
+    readonly SETTER: number;
+    readonly LIBERO: number;
+}
+export declare class Formation {
+    static readonly '5-1': Formation;
+    static readonly '4-2': Formation;
+    static readonly '6-2': Formation;
+    readonly name: string;
+    readonly initialRotation: PositionRole;
+    readonly base: PositionRole;
+    readonly draftingPriorities: Role[][];
+    readonly liberoSubPriority: SubPriority;
+    private constructor();
+    static getFormations(): Formation[];
+}
+export {};

package/dist/esm/service/coach/formation.js

@@ -0,0 +1,122 @@
+import { Role } from '../player';
+import { CourtPosition } from '../match';
+export class Formation {
+    constructor({ name, initialRotation, base, draftingPriorities, liberoSubPriority }) {
+        this.name = name;
+        this.initialRotation = initialRotation;
+        this.base = base;
+        this.draftingPriorities = draftingPriorities;
+        this.liberoSubPriority = liberoSubPriority;
+    }
+    static getFormations() {
+        return [this['4-2'], this['5-1'], this['6-2']];
+    }
+}
+Formation['5-1'] = new Formation({
+    name: '5-1',
+    initialRotation: {
+        1: [Role.SETTER],
+        2: [Role.OUTSIDE_HITTER],
+        3: [Role.MIDDLE_BLOCKER, Role.DEFENSIVE_SPECIALIST],
+        4: [Role.OPPOSITE_HITTER],
+        5: [Role.OUTSIDE_HITTER],
+        6: [Role.MIDDLE_BLOCKER, Role.DEFENSIVE_SPECIALIST]
+    },
+    base: {
+        1: [Role.OPPOSITE_HITTER, Role.SETTER],
+        2: [Role.OPPOSITE_HITTER],
+        3: [Role.MIDDLE_BLOCKER, Role.DEFENSIVE_SPECIALIST],
+        4: [Role.OUTSIDE_HITTER],
+        5: [Role.OUTSIDE_HITTER],
+        6: [Role.LIBERO, Role.DEFENSIVE_SPECIALIST]
+    },
+    draftingPriorities: [
+        [Role.SETTER, Role.OPPOSITE_HITTER],
+        [Role.OPPOSITE_HITTER],
+        [Role.MIDDLE_BLOCKER, Role.DEFENSIVE_SPECIALIST],
+        [Role.MIDDLE_BLOCKER],
+        [Role.OUTSIDE_HITTER],
+        [Role.OUTSIDE_HITTER],
+        [Role.LIBERO]
+    ],
+    liberoSubPriority: {
+        MIDDLE_BLOCKER: 1,
+        OUTSIDE_HITTER: 10,
+        OPPOSITE_HITTER: 100,
+        DEFENSIVE_SPECIALIST: 1000,
+        SETTER: 10000,
+        LIBERO: 100000
+    }
+});
+Formation['4-2'] = new Formation({
+    name: '4-2',
+    initialRotation: {
+        1: [Role.MIDDLE_BLOCKER, Role.DEFENSIVE_SPECIALIST],
+        2: [Role.SETTER],
+        3: [Role.OUTSIDE_HITTER],
+        4: [Role.MIDDLE_BLOCKER],
+        5: [Role.SETTER],
+        6: [Role.OPPOSITE_HITTER]
+    },
+    base: {
+        1: [Role.SETTER],
+        2: [Role.OPPOSITE_HITTER, Role.SETTER],
+        3: [Role.MIDDLE_BLOCKER, Role.DEFENSIVE_SPECIALIST],
+        4: [Role.OUTSIDE_HITTER],
+        5: [Role.OUTSIDE_HITTER],
+        6: [Role.LIBERO, Role.DEFENSIVE_SPECIALIST]
+    },
+    draftingPriorities: [
+        [Role.SETTER, Role.OPPOSITE_HITTER],
+        [Role.SETTER],
+        [Role.MIDDLE_BLOCKER, Role.DEFENSIVE_SPECIALIST],
+        [Role.MIDDLE_BLOCKER],
+        [Role.OUTSIDE_HITTER],
+        [Role.OUTSIDE_HITTER],
+        [Role.LIBERO]
+    ],
+    liberoSubPriority: {
+        MIDDLE_BLOCKER: 1,
+        OUTSIDE_HITTER: 10,
+        OPPOSITE_HITTER: 100,
+        DEFENSIVE_SPECIALIST: 1000,
+        SETTER: 10000,
+        LIBERO: 100000
+    }
+});
+Formation['6-2'] = new Formation({
+    name: '6-2',
+    initialRotation: {
+        1: [Role.OPPOSITE_HITTER, Role.SETTER],
+        2: [Role.OUTSIDE_HITTER],
+        3: [Role.MIDDLE_BLOCKER, Role.DEFENSIVE_SPECIALIST],
+        4: [Role.OPPOSITE_HITTER, Role.SETTER],
+        5: [Role.OUTSIDE_HITTER],
+        6: [Role.MIDDLE_BLOCKER]
+    },
+    base: {
+        1: [Role.SETTER],
+        2: [Role.OPPOSITE_HITTER, Role.SETTER],
+        3: [Role.MIDDLE_BLOCKER, Role.DEFENSIVE_SPECIALIST],
+        4: [Role.OUTSIDE_HITTER],
+        5: [Role.OUTSIDE_HITTER],
+        6: [Role.LIBERO, Role.DEFENSIVE_SPECIALIST]
+    },
+    draftingPriorities: [
+        [Role.SETTER, Role.OPPOSITE_HITTER],
+        [Role.OPPOSITE_HITTER, Role.SETTER],
+        [Role.MIDDLE_BLOCKER, Role.DEFENSIVE_SPECIALIST],
+        [Role.DEFENSIVE_SPECIALIST, Role.MIDDLE_BLOCKER],
+        [Role.OUTSIDE_HITTER],
+        [Role.OUTSIDE_HITTER],
+        [Role.LIBERO]
+    ],
+    liberoSubPriority: {
+        MIDDLE_BLOCKER: 1,
+        OUTSIDE_HITTER: 10,
+        OPPOSITE_HITTER: 100,
+        DEFENSIVE_SPECIALIST: 1000,
+        SETTER: 10000,
+        LIBERO: 100000
+    }
+});

package/dist/esm/service/coach/index.d.ts

@@ -0,0 +1,2 @@
+export * from './coach';
+export * from './formation';

package/dist/esm/service/coach/index.js

@@ -0,0 +1,2 @@
+export * from './coach';
+export * from './formation';

package/dist/esm/service/competition/index.d.ts

@@ -0,0 +1,11 @@
+export * from './standing';
+export * from './season';
+export * from './league';
+export * from './iteration';
+export * from './tournament';
+export * from './tournament-match';
+export * from './stage';
+export declare enum _CompetitionType {
+    TOURNAMENT = "TOURNAMENT",
+    LEAGUE = "LEAGUE"
+}

package/dist/esm/service/competition/index.js

@@ -0,0 +1,12 @@
+export * from './standing';
+export * from './season';
+export * from './league';
+export * from './iteration';
+export * from './tournament';
+export * from './tournament-match';
+export * from './stage';
+export var _CompetitionType;
+(function (_CompetitionType) {
+    _CompetitionType["TOURNAMENT"] = "TOURNAMENT";
+    _CompetitionType["LEAGUE"] = "LEAGUE";
+})(_CompetitionType || (_CompetitionType = {}));

package/dist/esm/service/competition/iteration.d.ts

@@ -0,0 +1,10 @@
+interface IterationOpts {
+    readonly id: number;
+    readonly startDate: Date;
+}
+export declare class Iteration {
+    readonly id: number;
+    readonly startDate: Date;
+    constructor({ id, startDate }: IterationOpts);
+}
+export {};

package/dist/esm/service/competition/iteration.js

@@ -0,0 +1,8 @@
+export class Iteration {
+    constructor({ id, startDate }) {
+        if (id < 1)
+            throw new Error(`INVALID_ITERATION: ${id}`);
+        this.id = id;
+        this.startDate = startDate;
+    }
+}

package/dist/esm/service/competition/league.d.ts

@@ -0,0 +1,16 @@
+import { Season } from './season';
+import { Country } from '../country';
+interface LeagueOpts {
+    readonly id: string;
+    readonly name: string;
+    readonly country: Country;
+    readonly seasons: Season[];
+}
+export declare class League {
+    readonly id: string;
+    readonly name: string;
+    readonly seasons: Season[];
+    readonly country: Country;
+    constructor({ id, name, country, seasons }: LeagueOpts);
+}
+export {};

package/dist/esm/service/competition/league.js

@@ -0,0 +1,8 @@
+export class League {
+    constructor({ id, name, country, seasons }) {
+        this.id = id;
+        this.name = name;
+        this.country = country;
+        this.seasons = seasons;
+    }
+}

package/dist/esm/service/competition/season.d.ts

@@ -0,0 +1,23 @@
+import { Team } from '../team';
+import { Match } from '../match';
+import { Standing } from './standing';
+import { Iteration } from './iteration';
+interface SeasonOpts {
+    readonly id: string;
+    readonly teams: Team[];
+    readonly matches: Match[];
+    readonly iteration: Iteration;
+    readonly champion?: Team;
+}
+export declare class Season {
+    readonly id: string;
+    readonly teams: Team[];
+    readonly matches: Match[];
+    readonly iteration: Iteration;
+    readonly standings: Standing[];
+    champion?: Team;
+    constructor({ id, iteration, teams, matches, champion }: SeasonOpts);
+    calculateStandings(): Standing[];
+    updateStandings(): void;
+}
+export {};

package/dist/esm/service/competition/season.js

@@ -0,0 +1,27 @@
+import { Standing } from './standing';
+export class Season {
+    constructor({ id, iteration, teams, matches, champion }) {
+        this.id = id;
+        this.teams = teams;
+        this.matches = matches;
+        this.iteration = iteration;
+        this.champion = champion;
+        this.standings = this.calculateStandings();
+    }
+    calculateStandings() {
+        return this.teams.map(team => {
+            const standing = new Standing({ team });
+            standing.calculateStanding(this.matches);
+            return standing;
+        }).sort(Standing.sortFn);
+    }
+    updateStandings() {
+        if (this.matches == null || this.matches.length < 1)
+            throw new Error('NO_MATCHES');
+        this.standings.length = 0;
+        this.standings.push(...this.calculateStandings());
+        if (this.matches.every((match) => match.isOver())) {
+            this.champion = this.standings[0].team;
+        }
+    }
+}

package/dist/esm/service/competition/stage.d.ts

@@ -0,0 +1,11 @@
+export declare enum Stage {
+    ROUND_OF_8 = 8,
+    QUARTERFINALS = 4,
+    SEMIFINALS = 2,
+    FINAL = 1,
+    LEAGUE = 0
+}
+export declare namespace Stage {
+    function getStages(): Stage[];
+    function getNextStage(stage: Stage): Stage;
+}

package/dist/esm/service/competition/stage.js

@@ -0,0 +1,24 @@
+export var Stage;
+(function (Stage) {
+    Stage[Stage["ROUND_OF_8"] = 8] = "ROUND_OF_8";
+    Stage[Stage["QUARTERFINALS"] = 4] = "QUARTERFINALS";
+    Stage[Stage["SEMIFINALS"] = 2] = "SEMIFINALS";
+    Stage[Stage["FINAL"] = 1] = "FINAL";
+    Stage[Stage["LEAGUE"] = 0] = "LEAGUE";
+})(Stage || (Stage = {}));
+// eslint-disable-next-line @typescript-eslint/no-namespace
+(function (Stage) {
+    const STAGES = [Stage.ROUND_OF_8, Stage.QUARTERFINALS, Stage.SEMIFINALS, Stage.FINAL, Stage.LEAGUE];
+    function getStages() {
+        return [...STAGES];
+    }
+    Stage.getStages = getStages;
+    function getNextStage(stage) {
+        if (stage < 1)
+            throw new Error(`INVALID_STAGE ${stage}`);
+        if (stage === 1)
+            throw new Error('ALREADY_IN_FINAL_STAGE');
+        return stage / 2;
+    }
+    Stage.getNextStage = getNextStage;
+})(Stage || (Stage = {}));