volleyballsimtypes 0.0.356 → 0.0.358

package/dist/esm/src/service/competition/qualifier.js

@@ -0,0 +1,45 @@
+import { Stage } from './stage';
+import { QualifierInputSchema } from './schemas/qualifier.z';
+export class Qualifier {
+    static create(input) {
+        const result = QualifierInputSchema.safeParse(input);
+        if (!result.success) {
+            throw new Error(`INVALID_QUALIFIER: ${result.error.message}. RECEIVED=${(() => { try {
+                return JSON.stringify(input);
+            }
+            catch {
+                return String(input);
+            } })()}`);
+        }
+        return new Qualifier(result.data);
+    }
+    constructor({ id, iteration, matches, teams, status, region, champion }) {
+        this.id = id;
+        this.iteration = iteration;
+        this.matches = matches;
+        this.teams = teams;
+        this.podium = [];
+        this.status = status;
+        this.region = region;
+        this.champion = champion;
+        this.matches.sort(Qualifier.sortMatchesFn);
+        const final = this.matches.find(m => m.stage === Stage.FINAL);
+        const thirdPlace = this.matches.find(m => m.stage === Stage.THIRD_PLACE);
+        if (final == null || thirdPlace == null)
+            return;
+        this.podium = [
+            final.match.getWinner(),
+            final.match.getWinner().id === final.match.homeTeam.id ? final.match.awayTeam : final.match.homeTeam,
+            thirdPlace.match.getWinner(),
+            thirdPlace.match.getWinner().id === thirdPlace.match.homeTeam.id ? thirdPlace.match.awayTeam : thirdPlace.match.homeTeam
+        ];
+    }
+    static sortMatchesFn(m1, m2) {
+        if (m1.stage > m2.stage)
+            return -1;
+        else if (m1.stage < m2.stage)
+            return 1;
+        else
+            return m1.index - m2.index;
+    }
+}

package/dist/esm/src/service/competition/schemas/division.z.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { Team } from '../../team';
+import { Season } from '../season';
+export declare const DivisionInputSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    tier: z.ZodNumber;
+    subdivision: z.ZodNumber;
+    leagueId: z.ZodUUID;
+    seasons: z.ZodArray<z.ZodCustom<Season, Season>>;
+    teams: z.ZodOptional<z.ZodArray<z.ZodCustom<Team, Team>>>;
+}, z.core.$strip>;
+export type DivisionInput = z.infer<typeof DivisionInputSchema>;

package/dist/esm/src/service/competition/schemas/division.z.js

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import { Team } from '../../team';
+import { Season } from '../season';
+const teamSchema = z.custom((v) => v instanceof Team, { message: 'INVALID_TEAM_INSTANCE' });
+const seasonSchema = z.custom((v) => v instanceof Season, { message: 'INVALID_SEASON_INSTANCE' });
+export const DivisionInputSchema = z.object({
+    id: z.uuid(),
+    tier: z.number().int().min(1),
+    subdivision: z.number().int().min(1),
+    leagueId: z.uuid(),
+    seasons: z.array(seasonSchema),
+    teams: z.array(teamSchema).optional()
+}).superRefine((data, ctx) => {
+    const maxSubdivision = Math.pow(2, data.tier - 1);
+    if (data.subdivision > maxSubdivision) {
+        ctx.addIssue({
+            code: 'custom',
+            message: `DIVISION_SUBDIVISION_OUT_OF_RANGE_MAX_${maxSubdivision}`,
+            path: ['subdivision']
+        });
+    }
+    if (data.teams != null) {
+        const ids = data.teams.map(t => t.id);
+        if (new Set(ids).size !== ids.length) {
+            ctx.addIssue({
+                code: 'custom',
+                message: 'DIVISION_TEAMS_CONTAINS_DUPLICATES',
+                path: ['teams']
+            });
+        }
+    }
+});

package/dist/esm/src/service/competition/schemas/iteration.z.d.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+export declare const IterationInputSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    startDate: z.ZodCoercedDate<unknown>;
+}, z.core.$strip>;
+export type IterationInput = z.infer<typeof IterationInputSchema>;

package/dist/esm/src/service/competition/schemas/iteration.z.js

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+export const IterationInputSchema = z.object({
+    id: z.number().int().min(1),
+    startDate: z.coerce.date()
+});

package/dist/esm/src/service/competition/schemas/league.z.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { Country } from '../../country';
+export declare const LeagueInputSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    name: z.ZodString;
+    country: z.ZodCustom<Country, Country>;
+    divisions: z.ZodArray<z.ZodObject<{
+        id: z.ZodUUID;
+        tier: z.ZodNumber;
+        subdivision: z.ZodNumber;
+        leagueId: z.ZodUUID;
+        seasons: z.ZodArray<z.ZodUnknown>;
+        teams: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type LeagueInput = z.infer<typeof LeagueInputSchema>;

package/dist/esm/src/service/competition/schemas/league.z.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { Country } from '../../country';
+const countrySchema = z.custom((v) => v instanceof Country, { message: 'INVALID_COUNTRY_INSTANCE' });
+const divisionSchema = z.object({
+    id: z.uuid(),
+    tier: z.number().int().min(1),
+    subdivision: z.number().int().min(1),
+    leagueId: z.uuid(),
+    seasons: z.array(z.unknown()),
+    teams: z.array(z.unknown()).optional()
+});
+export const LeagueInputSchema = z.object({
+    id: z.uuid(),
+    name: z.string().trim().min(1),
+    country: countrySchema,
+    divisions: z.array(divisionSchema)
+});

package/dist/esm/src/service/competition/schemas/promotion-match.z.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { Match } from '../../match';
+export declare const PromotionMatchInputSchema: z.ZodObject<{
+    upperCompetitionId: z.ZodUUID;
+    lowerCompetitionId: z.ZodUUID;
+    iteration: z.ZodNumber;
+    match: z.ZodCustom<Match, Match>;
+}, z.core.$strip>;
+export type PromotionMatchInput = z.infer<typeof PromotionMatchInputSchema>;

package/dist/esm/src/service/competition/schemas/promotion-match.z.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { Match } from '../../match';
+const matchSchema = z.custom((v) => v instanceof Match, { message: 'INVALID_MATCH_INSTANCE' });
+export const PromotionMatchInputSchema = z.object({
+    upperCompetitionId: z.uuid(),
+    lowerCompetitionId: z.uuid(),
+    iteration: z.number().int().min(1),
+    match: matchSchema
+}).superRefine((data, ctx) => {
+    if (data.upperCompetitionId === data.lowerCompetitionId) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'PROMOTION_MATCH_COMPETITION_IDS_CANNOT_BE_EQUAL',
+            path: ['lowerCompetitionId']
+        });
+    }
+});

package/dist/esm/src/service/competition/schemas/qualifier-match.z.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { Match } from '../../match';
+import { Stage } from '../stage';
+export declare const QualifierMatchInputSchema: z.ZodObject<{
+    stage: z.ZodCustom<Stage, Stage>;
+    match: z.ZodCustom<Match, Match>;
+    index: z.ZodNumber;
+}, z.core.$strip>;
+export type QualifierMatchInput = z.infer<typeof QualifierMatchInputSchema>;

package/dist/esm/src/service/competition/schemas/qualifier-match.z.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { Match } from '../../match';
+import { Stage } from '../stage';
+const matchSchema = z.custom((v) => v instanceof Match, { message: 'INVALID_MATCH_INSTANCE' });
+export const QualifierMatchInputSchema = z.object({
+    stage: z.custom((v) => typeof v === 'number', { message: 'INVALID_STAGE' }),
+    match: matchSchema,
+    index: z.number().int().min(0)
+}).superRefine((data, ctx) => {
+    if (Stage.LEAGUE === data.stage) {
+        ctx.addIssue({
+            code: 'custom',
+            message: `INVALID_STAGE: ${data.stage}`,
+            path: ['stage']
+        });
+    }
+});

package/dist/esm/src/service/competition/schemas/qualifier.z.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { Team } from '../../team';
+import { Iteration } from '../iteration';
+import { StatusEnum } from '../../../data/common';
+import { QualifierMatch } from '../qualifier-match';
+import { Region } from '../../country';
+export declare const QualifierInputSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    iteration: z.ZodCustom<Iteration, Iteration>;
+    matches: z.ZodArray<z.ZodCustom<QualifierMatch, QualifierMatch>>;
+    teams: z.ZodArray<z.ZodCustom<Team, Team>>;
+    status: z.ZodEnum<{
+        PENDING: StatusEnum.PENDING;
+        IN_PROGRESS: StatusEnum.IN_PROGRESS;
+        COMPLETE: StatusEnum.COMPLETE;
+    }>;
+    region: z.ZodCustom<Region, Region>;
+    champion: z.ZodOptional<z.ZodCustom<Team, Team>>;
+}, z.core.$strip>;
+export type QualifierInput = z.infer<typeof QualifierInputSchema>;

package/dist/esm/src/service/competition/schemas/qualifier.z.js

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { Team } from '../../team';
+import { Iteration } from '../iteration';
+import { StatusEnum } from '../../../data/common';
+import { QualifierMatch } from '../qualifier-match';
+const teamSchema = z.custom((v) => v instanceof Team, { message: 'INVALID_TEAM_INSTANCE' });
+const iterationSchema = z.custom((v) => v instanceof Iteration, { message: 'INVALID_ITERATION_INSTANCE' });
+const qualifierMatchSchema = z.custom((v) => v instanceof QualifierMatch, { message: 'INVALID_QUALIFIER_MATCH_INSTANCE' });
+const regionSchema = z.custom((v) => typeof v === 'object' && v != null && 'name' in v && 'code' in v, {
+    message: 'INVALID_REGION'
+});
+export const QualifierInputSchema = z.object({
+    id: z.uuid(),
+    iteration: iterationSchema,
+    matches: z.array(qualifierMatchSchema),
+    teams: z.array(teamSchema),
+    status: z.enum(Object.values(StatusEnum)),
+    region: regionSchema,
+    champion: teamSchema.optional()
+}).superRefine((data, ctx) => {
+    const ids = data.teams.map(t => t.id);
+    if (new Set(ids).size !== ids.length) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'QUALIFIER_TEAMS_CONTAINS_DUPLICATES',
+            path: ['teams']
+        });
+    }
+});

package/dist/esm/src/service/competition/schemas/season.z.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { Team } from '../../team';
+import { Match } from '../../match';
+import { Iteration } from '../iteration';
+import { StatusEnum } from '../../../data/common';
+import { Standing } from '../standing';
+export declare const SeasonInputSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    teams: z.ZodArray<z.ZodCustom<Team, Team>>;
+    matches: z.ZodArray<z.ZodCustom<Match, Match>>;
+    iteration: z.ZodCustom<Iteration, Iteration>;
+    divisionId: z.ZodUUID;
+    champion: z.ZodOptional<z.ZodCustom<Team, Team>>;
+    status: z.ZodEnum<{
+        PENDING: StatusEnum.PENDING;
+        IN_PROGRESS: StatusEnum.IN_PROGRESS;
+        COMPLETE: StatusEnum.COMPLETE;
+    }>;
+    standings: z.ZodOptional<z.ZodArray<z.ZodCustom<Standing, Standing>>>;
+}, z.core.$strip>;
+export type SeasonInput = z.infer<typeof SeasonInputSchema>;

package/dist/esm/src/service/competition/schemas/season.z.js

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { Team } from '../../team';
+import { Match } from '../../match';
+import { Iteration } from '../iteration';
+import { StatusEnum } from '../../../data/common';
+import { Standing } from '../standing';
+const teamSchema = z.custom((v) => v instanceof Team, { message: 'INVALID_TEAM_INSTANCE' });
+const matchSchema = z.custom((v) => v instanceof Match, { message: 'INVALID_MATCH_INSTANCE' });
+const iterationSchema = z.custom((v) => v instanceof Iteration, { message: 'INVALID_ITERATION_INSTANCE' });
+const standingSchema = z.custom((v) => v instanceof Standing, { message: 'INVALID_STANDING_INSTANCE' });
+export const SeasonInputSchema = z.object({
+    id: z.uuid(),
+    teams: z.array(teamSchema),
+    matches: z.array(matchSchema),
+    iteration: iterationSchema,
+    divisionId: z.uuid(),
+    champion: teamSchema.optional(),
+    status: z.enum(Object.values(StatusEnum)),
+    standings: z.array(standingSchema).optional()
+}).superRefine((data, ctx) => {
+    const ids = data.teams.map(t => t.id);
+    if (new Set(ids).size !== ids.length) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'SEASON_TEAMS_CONTAINS_DUPLICATES',
+            path: ['teams']
+        });
+    }
+});

package/dist/esm/src/service/competition/schemas/standing.z.d.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+export declare const StandingInputSchema: z.ZodObject<{
+    teamId: z.ZodUUID;
+    won30: z.ZodOptional<z.ZodNumber>;
+    won31: z.ZodOptional<z.ZodNumber>;
+    won32: z.ZodOptional<z.ZodNumber>;
+    lost03: z.ZodOptional<z.ZodNumber>;
+    lost13: z.ZodOptional<z.ZodNumber>;
+    lost23: z.ZodOptional<z.ZodNumber>;
+    pointsWon: z.ZodOptional<z.ZodNumber>;
+    pointsLost: z.ZodOptional<z.ZodNumber>;
+    points: z.ZodOptional<z.ZodNumber>;
+    setsWon: z.ZodOptional<z.ZodNumber>;
+    setsLost: z.ZodOptional<z.ZodNumber>;
+    matchesWon: z.ZodOptional<z.ZodNumber>;
+    matchesLost: z.ZodOptional<z.ZodNumber>;
+    totalMatches: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type StandingInput = z.infer<typeof StandingInputSchema>;

package/dist/esm/src/service/competition/schemas/standing.z.js

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+const nonNeg = z.number().int().min(0);
+export const StandingInputSchema = z.object({
+    teamId: z.uuid(),
+    won30: nonNeg.optional(),
+    won31: nonNeg.optional(),
+    won32: nonNeg.optional(),
+    lost03: nonNeg.optional(),
+    lost13: nonNeg.optional(),
+    lost23: nonNeg.optional(),
+    pointsWon: nonNeg.optional(),
+    pointsLost: nonNeg.optional(),
+    points: nonNeg.optional(),
+    setsWon: nonNeg.optional(),
+    setsLost: nonNeg.optional(),
+    matchesWon: nonNeg.optional(),
+    matchesLost: nonNeg.optional(),
+    totalMatches: nonNeg.optional()
+}).superRefine((data, ctx) => {
+    const won30 = data.won30 ?? 0;
+    const won31 = data.won31 ?? 0;
+    const won32 = data.won32 ?? 0;
+    const lost03 = data.lost03 ?? 0;
+    const lost13 = data.lost13 ?? 0;
+    const lost23 = data.lost23 ?? 0;
+    const expectedMatchesWon = won30 + won31 + won32;
+    const expectedMatchesLost = lost03 + lost13 + lost23;
+    const expectedTotalMatches = expectedMatchesWon + expectedMatchesLost;
+    const expectedPoints = (won30 + won31) * 3 + won32 * 2 + lost23;
+    const expectedSetsWon = (won32 + won31 + won30) * 3 + lost23 * 2 + lost13;
+    const expectedSetsLost = (lost03 + lost13 + lost23) * 3 + won32 * 2 + won31;
+    if (data.matchesWon != null && data.matchesWon !== expectedMatchesWon) {
+        ctx.addIssue({ code: 'custom', message: `MATCHES_WON_MISMATCH_EXPECTED_${expectedMatchesWon}`, path: ['matchesWon'] });
+    }
+    if (data.matchesLost != null && data.matchesLost !== expectedMatchesLost) {
+        ctx.addIssue({ code: 'custom', message: `MATCHES_LOST_MISMATCH_EXPECTED_${expectedMatchesLost}`, path: ['matchesLost'] });
+    }
+    if (data.totalMatches != null && data.totalMatches !== expectedTotalMatches) {
+        ctx.addIssue({ code: 'custom', message: `TOTAL_MATCHES_MISMATCH_EXPECTED_${expectedTotalMatches}`, path: ['totalMatches'] });
+    }
+    if ((data.points ?? 0) !== expectedPoints) {
+        ctx.addIssue({ code: 'custom', message: `POINTS_MISMATCH_EXPECTED_${expectedPoints}`, path: ['points'] });
+    }
+    if ((data.setsWon ?? 0) !== expectedSetsWon) {
+        ctx.addIssue({ code: 'custom', message: `SETS_WON_MISMATCH_EXPECTED_${expectedSetsWon}`, path: ['setsWon'] });
+    }
+    if ((data.setsLost ?? 0) !== expectedSetsLost) {
+        ctx.addIssue({ code: 'custom', message: `SETS_LOST_MISMATCH_EXPECTED_${expectedSetsLost}`, path: ['setsLost'] });
+    }
+});

package/dist/esm/src/service/competition/schemas/tournament-match.z.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { Match } from '../../match';
+import { Stage } from '../stage';
+export declare const TournamentMatchInputSchema: z.ZodObject<{
+    stage: z.ZodCustom<Stage, Stage>;
+    match: z.ZodCustom<Match, Match>;
+    index: z.ZodNumber;
+}, z.core.$strip>;
+export type TournamentMatchInput = z.infer<typeof TournamentMatchInputSchema>;

package/dist/esm/src/service/competition/schemas/tournament-match.z.js

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { Match } from '../../match';
+import { Stage } from '../stage';
+const matchSchema = z.custom((v) => v instanceof Match, { message: 'INVALID_MATCH_INSTANCE' });
+export const TournamentMatchInputSchema = z.object({
+    stage: z.custom((v) => typeof v === 'number', { message: 'INVALID_STAGE' }),
+    match: matchSchema,
+    index: z.number().int().min(0)
+}).superRefine((data, ctx) => {
+    if (Stage.LEAGUE === data.stage) {
+        ctx.addIssue({ code: 'custom', message: `INVALID_STAGE: ${data.stage}`, path: ['stage'] });
+    }
+    if (data.index > data.stage) {
+        ctx.addIssue({ code: 'custom', message: 'INDEX_OUT_OF_BOUNDS', path: ['index'] });
+    }
+});

package/dist/esm/src/service/competition/schemas/tournament.z.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { Team } from '../../team';
+import { Iteration } from '../iteration';
+import { StatusEnum } from '../../../data/common';
+import { TournamentMatch } from '../tournament-match';
+export declare const TournamentInputSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    iteration: z.ZodCustom<Iteration, Iteration>;
+    matches: z.ZodArray<z.ZodCustom<TournamentMatch, TournamentMatch>>;
+    teams: z.ZodArray<z.ZodCustom<Team, Team>>;
+    champion: z.ZodOptional<z.ZodCustom<Team, Team>>;
+    status: z.ZodEnum<{
+        PENDING: StatusEnum.PENDING;
+        IN_PROGRESS: StatusEnum.IN_PROGRESS;
+        COMPLETE: StatusEnum.COMPLETE;
+    }>;
+}, z.core.$strip>;
+export type TournamentInput = z.infer<typeof TournamentInputSchema>;

package/dist/esm/src/service/competition/schemas/tournament.z.js

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import { Team } from '../../team';
+import { Iteration } from '../iteration';
+import { StatusEnum } from '../../../data/common';
+import { TournamentMatch } from '../tournament-match';
+const teamSchema = z.custom((v) => v instanceof Team, { message: 'INVALID_TEAM_INSTANCE' });
+const iterationSchema = z.custom((v) => v instanceof Iteration, { message: 'INVALID_ITERATION_INSTANCE' });
+const tournamentMatchSchema = z.custom((v) => v instanceof TournamentMatch, { message: 'INVALID_TOURNAMENT_MATCH_INSTANCE' });
+export const TournamentInputSchema = z.object({
+    id: z.uuid(),
+    iteration: iterationSchema,
+    matches: z.array(tournamentMatchSchema),
+    teams: z.array(teamSchema),
+    champion: teamSchema.optional(),
+    status: z.enum(Object.values(StatusEnum))
+}).superRefine((data, ctx) => {
+    const ids = data.teams.map(t => t.id);
+    if (new Set(ids).size !== ids.length) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'TOURNAMENT_TEAMS_CONTAINS_DUPLICATES',
+            path: ['teams']
+        });
+    }
+});

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

@@ -0,0 +1,22 @@
+import { Team } from '../team';
+import { Match } from '../match';
+import { Standing } from './standing';
+import { Iteration } from './iteration';
+import { Status } from '../../data';
+export declare class Season {
+    readonly id: string;
+    readonly teams: Team[];
+    readonly matches: Match[];
+    readonly iteration: Iteration;
+    readonly divisionId: string;
+    readonly standings: Standing[];
+    private _status;
+    private _champion?;
+    static create(input: unknown): Season;
+    private constructor();
+    calculateStandings(): Standing[];
+    updateStandings(): void;
+    get champion(): Team | undefined;
+    get status(): Status;
+    static createSeason(iteration: Iteration, teams: Team[], divisionId: string): Season;
+}

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

@@ -0,0 +1,68 @@
+import { Standing } from './standing';
+import { StatusEnum } from '../../data';
+import { v4 as uuidv4 } from 'uuid';
+import MatchGenerator from '../match/match-generator';
+import { SeasonInputSchema } from './schemas/season.z';
+export class Season {
+    static create(input) {
+        const result = SeasonInputSchema.safeParse(input);
+        if (!result.success) {
+            throw new Error(`INVALID_SEASON: ${result.error.message}. RECEIVED=${(() => { try {
+                return JSON.stringify(input);
+            }
+            catch {
+                return String(input);
+            } })()}`);
+        }
+        return new Season(result.data);
+    }
+    constructor({ id, iteration, teams, matches, champion, status, divisionId, standings }) {
+        this.id = id;
+        this.teams = teams;
+        this.matches = matches;
+        this.iteration = iteration;
+        this.divisionId = divisionId;
+        this._champion = champion;
+        this.standings = standings ?? this.calculateStandings();
+        this._status = status;
+        this.standings.sort(Standing.sortFn(matches));
+    }
+    calculateStandings() {
+        return this.teams.map(team => {
+            const standing = Standing.create({ teamId: team.id });
+            standing.calculateStanding(this.matches);
+            return standing;
+        });
+    }
+    updateStandings() {
+        if (this.matches == null || this.matches.length < 1)
+            throw new Error('NO_MATCHES');
+        const updated = this.calculateStandings();
+        this.standings.splice(0, this.standings.length, ...updated);
+        const isOver = this.matches.every((match) => match.isOver());
+        if (isOver) {
+            this._status = StatusEnum.COMPLETE;
+            this._champion = this.teams.find((team) => team.id === this.standings[0].teamId);
+        }
+    }
+    get champion() {
+        if (this._champion != null)
+            return this._champion;
+        if (this._status !== StatusEnum.COMPLETE)
+            return;
+        return this.teams.find((team) => team.id === this.standings[0].teamId);
+    }
+    get status() {
+        return this._status;
+    }
+    static createSeason(iteration, teams, divisionId) {
+        return Season.create({
+            id: uuidv4(),
+            matches: MatchGenerator.generateMatches(teams, iteration.startDate),
+            iteration,
+            teams,
+            status: StatusEnum.PENDING,
+            divisionId
+        });
+    }
+}

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

@@ -0,0 +1,17 @@
+export declare enum Stage {
+    ROUND_OF_256 = 256,
+    ROUND_OF_128 = 128,
+    ROUND_OF_64 = 64,
+    ROUND_OF_32 = 32,
+    ROUND_OF_16 = 16,
+    ROUND_OF_8 = 8,
+    QUARTERFINALS = 4,
+    SEMIFINALS = 2,
+    THIRD_PLACE = 1.5,
+    FINAL = 1,
+    LEAGUE = 0
+}
+export declare namespace Stage {
+    function stageFromValue(value: number): Stage;
+    function getNextStage(stage: Stage): Stage;
+}

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

@@ -0,0 +1,34 @@
+export var Stage;
+(function (Stage) {
+    Stage[Stage["ROUND_OF_256"] = 256] = "ROUND_OF_256";
+    Stage[Stage["ROUND_OF_128"] = 128] = "ROUND_OF_128";
+    Stage[Stage["ROUND_OF_64"] = 64] = "ROUND_OF_64";
+    Stage[Stage["ROUND_OF_32"] = 32] = "ROUND_OF_32";
+    Stage[Stage["ROUND_OF_16"] = 16] = "ROUND_OF_16";
+    Stage[Stage["ROUND_OF_8"] = 8] = "ROUND_OF_8";
+    Stage[Stage["QUARTERFINALS"] = 4] = "QUARTERFINALS";
+    Stage[Stage["SEMIFINALS"] = 2] = "SEMIFINALS";
+    Stage[Stage["THIRD_PLACE"] = 1.5] = "THIRD_PLACE";
+    Stage[Stage["FINAL"] = 1] = "FINAL";
+    Stage[Stage["LEAGUE"] = 0] = "LEAGUE";
+})(Stage || (Stage = {}));
+// eslint-disable-next-line @typescript-eslint/no-namespace
+(function (Stage) {
+    function stageFromValue(value) {
+        const byNumber = Stage;
+        const byName = Stage;
+        const key = byNumber[value];
+        if (key == null)
+            throw new Error(`INVALID_STAGE_VALUE ${value}`);
+        return byName[key];
+    }
+    Stage.stageFromValue = stageFromValue;
+    function getNextStage(stage) {
+        if (stage < 1)
+            throw new Error(`INVALID_STAGE ${stage}`);
+        if (stage < 2)
+            throw new Error('ALREADY_IN_FINAL_STAGE');
+        return stageFromValue(stage / 2);
+    }
+    Stage.getNextStage = getNextStage;
+})(Stage || (Stage = {}));

package/dist/esm/src/service/competition/standing.d.ts

@@ -0,0 +1,24 @@
+import { Match } from '../match';
+export declare class Standing {
+    readonly teamId: string;
+    won30: number;
+    won31: number;
+    won32: number;
+    lost03: number;
+    lost13: number;
+    lost23: number;
+    pointsWon: number;
+    pointsLost: number;
+    points: number;
+    pointsRatio: number;
+    setsWon: number;
+    setsLost: number;
+    setsRatio: number;
+    matchesWon: number;
+    matchesLost: number;
+    totalMatches: number;
+    static create(input: unknown): Standing;
+    private constructor();
+    static sortFn(matches: Match[]): (a: Standing, b: Standing) => number;
+    calculateStanding(matches: Match[]): void;
+}