volleyballsimtypes 0.0.359 → 0.0.360

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

@@ -0,0 +1,46 @@
+import { sortTeamsByCompetitionIndex, transformFromSeasonMatch, transformToIteration, transformToMatch, transformToStanding, transformToTeam } from '.';
+import { Season } from '../../service';
+function transformToAttributes(season) {
+    const matches = (season.matches ?? []).map((match, index) => transformFromSeasonMatch(season.id, match, index));
+    const teams = season.teams.map((team, index) => ({
+        competition_id: season.id,
+        team_id: team.id,
+        index
+    }));
+    const champion = season.champion != null
+        ? {
+            competition_id: season.id,
+            team_id: season.champion.id
+        }
+        : undefined;
+    const DivisionSeason = {
+        competition_id: season.id,
+        division_id: season.divisionId
+    };
+    return {
+        competition_id: season.id,
+        type: 'LEAGUE',
+        iteration: season.iteration.id,
+        CompetitionChampion: champion,
+        CompetitionMatches: matches,
+        CompetitionTeams: teams,
+        status: season.status,
+        DivisionSeason
+    };
+}
+function transformToObject(model) {
+    const standings = model.CompetitionStandings != null && model.CompetitionStandings.length > 0
+        ? model.CompetitionStandings.map(transformToStanding)
+        : undefined;
+    return Season.create({
+        id: model.competition_id,
+        matches: (model.CompetitionMatches ?? []).map((matches) => transformToMatch(matches.Match)),
+        iteration: transformToIteration(model.Iteration),
+        teams: sortTeamsByCompetitionIndex(model.Teams ?? []).map(transformToTeam),
+        champion: model.CompetitionChampion != null ? transformToTeam(model.CompetitionChampion.team) : undefined,
+        status: model.status,
+        divisionId: model.DivisionSeason.division_id,
+        standings
+    });
+}
+export { transformToObject as transformToSeason, transformToAttributes as transformFromSeason };

package/dist/esm/src/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/src/data/transformers/stage.js

@@ -0,0 +1,33 @@
+import { Stage } from '../../service';
+function transformToType(stage) {
+    switch (stage) {
+        case Stage.ROUND_OF_256:
+            return 'ROUND_OF_256';
+        case Stage.ROUND_OF_128:
+            return 'ROUND_OF_128';
+        case Stage.ROUND_OF_64:
+            return 'ROUND_OF_64';
+        case Stage.ROUND_OF_32:
+            return 'ROUND_OF_32';
+        case Stage.ROUND_OF_16:
+            return 'ROUND_OF_16';
+        case Stage.ROUND_OF_8:
+            return 'ROUND_OF_8';
+        case Stage.THIRD_PLACE:
+            return 'THIRD_PLACE';
+        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/src/data/transformers/standing.d.ts

@@ -0,0 +1,4 @@
+import { CompetitionStandingsModel } from '../models';
+import { Standing } from '../../service';
+declare function transformToObject(model: CompetitionStandingsModel): Standing;
+export { transformToObject as transformToStanding };

package/dist/esm/src/data/transformers/standing.js

@@ -0,0 +1,18 @@
+import { Standing } from '../../service';
+function transformToObject(model) {
+    return Standing.create({
+        teamId: model.team_id,
+        won30: Number(model.won30),
+        won31: Number(model.won31),
+        won32: Number(model.won32),
+        lost03: Number(model.lost03),
+        lost13: Number(model.lost13),
+        lost23: Number(model.lost23),
+        pointsWon: Number(model.points_won),
+        pointsLost: Number(model.points_lost),
+        points: Number(model.points),
+        setsWon: Number(model.sets_won),
+        setsLost: Number(model.sets_lost)
+    });
+}
+export { transformToObject as transformToStanding };

package/dist/esm/src/data/transformers/tactics.d.ts

@@ -0,0 +1,5 @@
+import { TacticsAttributes, TacticsModel } from '../models';
+import { Player, Tactics } from '../../service';
+declare function transformToAttributes(tactics: Tactics, teamId: string): TacticsAttributes;
+declare function transformToObject(model: TacticsModel, roster: Player[]): Tactics;
+export { transformToObject as transformToTactics, transformToAttributes as transformFromTactics };

package/dist/esm/src/data/transformers/tactics.js

@@ -0,0 +1,56 @@
+import { CourtPosition, Tactics } from '../../service';
+function findPlayer(id, roster) {
+    const player = roster.find((p) => p.id === id);
+    if (player == null)
+        throw new Error(`PLAYER_NOT_FOUND: ${id}`);
+    return player;
+}
+function transformFromLineup(lineup) {
+    return {
+        [CourtPosition.LIBERO_ZONE]: lineup[CourtPosition.LIBERO_ZONE] != null ? lineup[CourtPosition.LIBERO_ZONE].id : undefined,
+        [CourtPosition.LEFT_BACK]: lineup[CourtPosition.LEFT_BACK].id,
+        [CourtPosition.LEFT_FRONT]: lineup[CourtPosition.LEFT_FRONT].id,
+        [CourtPosition.MIDDLE_BACK]: lineup[CourtPosition.MIDDLE_BACK].id,
+        [CourtPosition.MIDDLE_FRONT]: lineup[CourtPosition.MIDDLE_FRONT].id,
+        [CourtPosition.RIGHT_BACK]: lineup[CourtPosition.RIGHT_BACK].id,
+        [CourtPosition.RIGHT_FRONT]: lineup[CourtPosition.RIGHT_FRONT].id,
+        bench: lineup.bench.map((b) => b.id)
+    };
+}
+function transformToLineup(lineup, roster) {
+    return {
+        [CourtPosition.LIBERO_ZONE]: roster.find((p) => p.id === lineup[CourtPosition.LIBERO_ZONE]),
+        [CourtPosition.LEFT_BACK]: findPlayer(lineup[CourtPosition.LEFT_BACK], roster),
+        [CourtPosition.LEFT_FRONT]: findPlayer(lineup[CourtPosition.LEFT_FRONT], roster),
+        [CourtPosition.MIDDLE_BACK]: findPlayer(lineup[CourtPosition.MIDDLE_BACK], roster),
+        [CourtPosition.MIDDLE_FRONT]: findPlayer(lineup[CourtPosition.MIDDLE_FRONT], roster),
+        [CourtPosition.RIGHT_BACK]: findPlayer(lineup[CourtPosition.RIGHT_BACK], roster),
+        [CourtPosition.RIGHT_FRONT]: findPlayer(lineup[CourtPosition.RIGHT_FRONT], roster),
+        bench: lineup.bench.map((b) => findPlayer(b, roster))
+    };
+}
+function transformToAttributes(tactics, teamId) {
+    return {
+        team_id: teamId,
+        substitution_tolerance: tactics.substitutionTolerance ?? 0,
+        lineup: transformFromLineup(tactics.lineup),
+        libero_replacements: tactics.liberoReplacements.map((lr) => lr.id),
+        pinch_server_subs: Object.fromEntries([...tactics.pinchServerSubs].map(([k, v]) => [k.id, v.id]))
+    };
+}
+function buildPinchServerSubs(pinchServerSubs, roster) {
+    const map = new Map();
+    for (const [key, value] of Object.entries(pinchServerSubs)) {
+        map.set(findPlayer(key, roster), findPlayer(value, roster));
+    }
+    return map;
+}
+function transformToObject(model, roster) {
+    return Tactics.create({
+        substitutionTolerance: model.substitution_tolerance,
+        lineup: transformToLineup(model.lineup, roster),
+        liberoReplacements: model.libero_replacements.map((lr) => findPlayer(lr, roster)),
+        pinchServerSubs: buildPinchServerSubs(model.pinch_server_subs, roster)
+    });
+}
+export { transformToObject as transformToTactics, transformToAttributes as transformFromTactics };

package/dist/esm/src/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(model: TeamModel): Team;
+export { transformToObject as transformToTeam, transformToAttributes as transformFromTeam };

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

@@ -0,0 +1,31 @@
+import { Team } from '../../service';
+import { transformFromTactics, transformToCountry, transformToPlayer, transformToTactics } from '.';
+function transformToAttributes(team) {
+    return {
+        team_id: team.id,
+        name: team.name,
+        short_name: team.shortName,
+        country_id: team.country?.id,
+        tactics: team.tactics != null ? transformFromTactics(team.tactics, team.id) : undefined,
+        rating: team.rating,
+        active: true,
+        division_id: team.divisionId
+    };
+}
+function transformToObject(model) {
+    const roster = (model.PlayerTeams ?? []).map((pt) => transformToPlayer(pt.player));
+    const tactics = model.tactics != null && roster != null && roster.length > 0
+        ? transformToTactics(model.tactics, roster)
+        : undefined;
+    return Team.create({
+        id: model.team_id,
+        name: model.name,
+        shortName: model.short_name,
+        country: transformToCountry(model.country),
+        rating: model.rating,
+        tactics,
+        roster,
+        divisionId: model.division_id
+    });
+}
+export { transformToObject as transformToTeam, transformToAttributes as transformFromTeam };

package/dist/esm/src/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/src/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 TournamentMatch.create({
+        stage: transformToStage(model.stage),
+        match: transformToMatch(model.Match),
+        index: model.index
+    });
+}
+export { transformToObject as transformToTournamentMatch, transformToAttributes as transformFromTournamentMatch };

package/dist/esm/src/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/src/data/transformers/tournament.js

@@ -0,0 +1,49 @@
+import { sortTeamsByCompetitionIndex, transformFromTournamentMatch, transformToIteration, transformToTeam, transformToTournamentMatch } from '.';
+import { Tournament } from '../../service';
+function transformToAttributes(tournament) {
+    const CompetitionMatches = tournament.matches.map((match) => transformFromTournamentMatch(match, tournament.id));
+    const seenTeamIds = new Set();
+    const duplicateTeamIds = new Set();
+    for (const team of tournament.teams) {
+        if (seenTeamIds.has(team.id))
+            duplicateTeamIds.add(team.id);
+        seenTeamIds.add(team.id);
+    }
+    if (duplicateTeamIds.size > 0) {
+        throw new Error(`TOURNAMENT_DUPLICATE_TEAMS tournamentId=${tournament.id} duplicateTeamIds=${Array.from(duplicateTeamIds).join(',')}`);
+    }
+    const CompetitionTeams = tournament.teams.map((team, index) => ({
+        competition_id: tournament.id,
+        team_id: team.id,
+        index
+    }));
+    const CompetitionChampion = (tournament.champion != null)
+        ? {
+            competition_id: tournament.id,
+            team_id: tournament.champion.id
+        }
+        : undefined;
+    return {
+        competition_id: tournament.id,
+        type: 'TOURNAMENT',
+        iteration: tournament.iteration.id,
+        status: tournament.status,
+        CompetitionChampion,
+        CompetitionMatches,
+        CompetitionTeams
+    };
+}
+function transformToObject(model) {
+    const champion = model.CompetitionChampion?.team != null
+        ? transformToTeam(model.CompetitionChampion.team)
+        : undefined;
+    return Tournament.create({
+        id: model.competition_id,
+        iteration: transformToIteration(model.Iteration),
+        matches: (model.CompetitionMatches ?? []).map(transformToTournamentMatch),
+        teams: sortTeamsByCompetitionIndex(model.Teams ?? []).map(transformToTeam),
+        status: model.status,
+        champion
+    });
+}
+export { transformToObject as transformToTournament, transformToAttributes as transformFromTournament };

package/dist/esm/src/data/transformers/vper.d.ts

@@ -0,0 +1,5 @@
+import { VPERAttributes, VPERModel } from '../models';
+import { VPER } from '../../service';
+declare function transformToAttributes(vper: VPER): VPERAttributes;
+declare function transformToObject(model: VPERModel): VPER;
+export { transformToObject as transformToVPER, transformToAttributes as transformFromVPER };

package/dist/esm/src/data/transformers/vper.js

@@ -0,0 +1,16 @@
+import { VPER } from '../../service';
+function transformToAttributes(vper) {
+    return {
+        player_id: vper.playerId,
+        match_id: vper.matchId,
+        value: vper.value
+    };
+}
+function transformToObject(model) {
+    return VPER.create({
+        playerId: model.player_id,
+        matchId: model.match_id,
+        value: model.value
+    });
+}
+export { transformToObject as transformToVPER, transformToAttributes as transformFromVPER };

package/dist/esm/src/index.d.ts

@@ -0,0 +1,3 @@
+export * from './service';
+export * from './data';
+export * from './stat-config';

package/dist/esm/src/index.js

@@ -0,0 +1,3 @@
+export * from './service';
+export * from './data';
+export * from './stat-config';

package/dist/esm/src/logger.d.ts

@@ -0,0 +1,3 @@
+import pino from 'pino';
+declare const logger: pino.Logger<never, boolean>;
+export default logger;

package/dist/esm/src/logger.js

@@ -0,0 +1,21 @@
+import pino from 'pino';
+const isProd = process.env.NODE_ENV === 'production';
+function buildTransport() {
+    if (isProd)
+        return undefined;
+    try {
+        return pino.transport({
+            target: 'pino-pretty',
+            options: {
+                colorize: false,
+                translateTime: 'SYS:standard',
+                ignore: 'pid,hostname'
+            }
+        });
+    }
+    catch {
+        return undefined;
+    }
+}
+const logger = pino({ level: process.env.LOG_LEVEL ?? 'info' }, buildTransport());
+export default logger;

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

@@ -0,0 +1,22 @@
+import { Season } from './season';
+import { Team } from '../team';
+import { Country } from '../country';
+import { Iteration } from './iteration';
+interface LeagueDivisionContext {
+    readonly id: string;
+    readonly name: string;
+    readonly country: Country;
+    readonly divisions: Division[];
+}
+export declare class Division {
+    readonly id: string;
+    readonly tier: number;
+    readonly subdivision: number;
+    readonly leagueId: string;
+    readonly seasons: Season[];
+    readonly teams?: Team[];
+    static create(input: unknown): Division;
+    private constructor();
+    static createDivisions(league: LeagueDivisionContext, iterations: Iteration[]): Division[];
+}
+export {};

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

@@ -0,0 +1,47 @@
+import { Season } from './season';
+import { v4 as uuidv4 } from 'uuid';
+import { TeamGenerator } from '../team/team-generator';
+import logger from '../../logger';
+import { DivisionInputSchema } from './schemas/division.z';
+export class Division {
+    static create(input) {
+        const result = DivisionInputSchema.safeParse(input);
+        if (!result.success) {
+            throw new Error(`INVALID_DIVISION: ${result.error.message}. RECEIVED=${(() => { try {
+                return JSON.stringify(input);
+            }
+            catch {
+                return String(input);
+            } })()}`);
+        }
+        return new Division(result.data);
+    }
+    constructor({ id, tier, subdivision, seasons, teams, leagueId }) {
+        this.id = id;
+        this.tier = tier;
+        this.subdivision = subdivision;
+        this.leagueId = leagueId;
+        this.seasons = seasons;
+        this.teams = teams;
+    }
+    static createDivisions(league, iterations) {
+        const highestTier = league.divisions.reduce((max, division) => Math.max(max, division.tier), 0);
+        const divisionsToCreate = Math.pow(2, highestTier);
+        logger.info(`Creating Divisions for League: ${league.name}`);
+        return Array.from({ length: divisionsToCreate }, (_, index) => {
+            const tier = highestTier + 1;
+            const subdivision = index + 1;
+            const id = uuidv4();
+            const teams = TeamGenerator.createTeams(id, league.country);
+            const seasons = Array.from({ length: iterations.length }, (_, i) => Season.createSeason(iterations[i], teams, id));
+            return Division.create({
+                leagueId: league.id,
+                id,
+                tier,
+                subdivision,
+                seasons,
+                teams
+            });
+        });
+    }
+}

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

@@ -0,0 +1,11 @@
+export * from './standing';
+export * from './season';
+export * from './league';
+export * from './division';
+export * from './iteration';
+export * from './tournament';
+export * from './tournament-match';
+export * from './promotion-match';
+export * from './stage';
+export * from './qualifier-match';
+export * from './qualifier';

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

@@ -0,0 +1,11 @@
+export * from './standing';
+export * from './season';
+export * from './league';
+export * from './division';
+export * from './iteration';
+export * from './tournament';
+export * from './tournament-match';
+export * from './promotion-match';
+export * from './stage';
+export * from './qualifier-match';
+export * from './qualifier';

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

@@ -0,0 +1,6 @@
+export declare class Iteration {
+    readonly id: number;
+    readonly startDate: Date;
+    static create(input: unknown): Iteration;
+    private constructor();
+}

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

@@ -0,0 +1,19 @@
+import { IterationInputSchema } from './schemas/iteration.z';
+export class Iteration {
+    static create(input) {
+        const result = IterationInputSchema.safeParse(input);
+        if (!result.success) {
+            throw new Error(`INVALID_ITERATION: ${result.error.message}. RECEIVED=${(() => { try {
+                return JSON.stringify(input);
+            }
+            catch {
+                return String(input);
+            } })()}`);
+        }
+        return new Iteration(result.data);
+    }
+    constructor({ id, startDate }) {
+        this.id = id;
+        this.startDate = startDate;
+    }
+}

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

@@ -0,0 +1,12 @@
+import { Country } from '../country';
+import { Division } from './division';
+import { Iteration } from './iteration';
+export declare class League {
+    readonly id: string;
+    readonly name: string;
+    readonly divisions: Division[];
+    readonly country: Country;
+    static create(input: unknown): League;
+    private constructor();
+    static createLeagues(countries: Country[], iterations: Iteration[], divCount: number): League[];
+}

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

@@ -0,0 +1,42 @@
+import { Division } from './division';
+import { v4 as uuidv4 } from 'uuid';
+import logger from '../../logger';
+import { LeagueInputSchema } from './schemas/league.z';
+export class League {
+    static create(input) {
+        const result = LeagueInputSchema.safeParse(input);
+        if (!result.success) {
+            throw new Error(`INVALID_LEAGUE: ${result.error.message}. RECEIVED=${(() => { try {
+                return JSON.stringify(input);
+            }
+            catch {
+                return String(input);
+            } })()}`);
+        }
+        return new League(result.data);
+    }
+    constructor({ id, name, country, divisions }) {
+        this.id = id;
+        this.name = name;
+        this.country = country;
+        this.divisions = divisions;
+    }
+    static createLeagues(countries, iterations, divCount) {
+        const leagues = [];
+        logger.info('Creating Leagues');
+        for (const country of countries) {
+            const league = League.create({
+                id: uuidv4(),
+                name: `${country.name} League`,
+                country,
+                divisions: []
+            });
+            for (let i = 0; i < divCount; i++) {
+                league.divisions.push(...Division.createDivisions(league, iterations));
+            }
+            logger.info(`Created League: ${league.name}`);
+            leagues.push(league);
+        }
+        return leagues;
+    }
+}

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

@@ -0,0 +1,9 @@
+import { Match } from '../match';
+export declare class PromotionMatch {
+    readonly upperCompetitionId: string;
+    readonly lowerCompetitionId: string;
+    readonly iteration: number;
+    readonly match: Match;
+    static create(input: unknown): PromotionMatch;
+    private constructor();
+}

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

@@ -0,0 +1,25 @@
+import { PromotionMatchInputSchema } from './schemas/promotion-match.z';
+export class PromotionMatch {
+    static create(input) {
+        const result = PromotionMatchInputSchema.safeParse(input);
+        if (!result.success) {
+            throw new Error(`INVALID_PROMOTION_MATCH: ${result.error.message}. RECEIVED=${(() => { try {
+                return JSON.stringify(input);
+            }
+            catch {
+                return String(input);
+            } })()}`);
+        }
+        return new PromotionMatch(result.data);
+    }
+    constructor({ upperCompetitionId, lowerCompetitionId, iteration, match }) {
+        if (upperCompetitionId === lowerCompetitionId)
+            throw new Error('PROMOTION_MATCH_COMPETITION_IDS_CANNOT_BE_EQUAL');
+        if (iteration < 1)
+            throw new Error(`INVALID_ITERATION: ${iteration}`);
+        this.upperCompetitionId = upperCompetitionId;
+        this.lowerCompetitionId = lowerCompetitionId;
+        this.iteration = iteration;
+        this.match = match;
+    }
+}

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

@@ -0,0 +1,9 @@
+import { Match } from '../match';
+import { Stage } from './stage';
+export declare class QualifierMatch {
+    readonly stage: Stage;
+    readonly match: Match;
+    readonly index: number;
+    static create(input: unknown): QualifierMatch;
+    private constructor();
+}

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

@@ -0,0 +1,23 @@
+import { Stage } from './stage';
+import { QualifierMatchInputSchema } from './schemas/qualifier-match.z';
+export class QualifierMatch {
+    static create(input) {
+        const result = QualifierMatchInputSchema.safeParse(input);
+        if (!result.success) {
+            throw new Error(`INVALID_QUALIFIER_MATCH: ${result.error.message}. RECEIVED=${(() => { try {
+                return JSON.stringify(input);
+            }
+            catch {
+                return String(input);
+            } })()}`);
+        }
+        return new QualifierMatch(result.data);
+    }
+    constructor({ stage, match, index }) {
+        if (Stage.LEAGUE === stage)
+            throw new Error(`INVALID_STAGE: ${stage}`);
+        this.stage = stage;
+        this.match = match;
+        this.index = index;
+    }
+}

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

@@ -0,0 +1,18 @@
+import { Team } from '../team';
+import { Iteration } from './iteration';
+import { StatusEnum } from '../../data';
+import { QualifierMatch } from './qualifier-match';
+import { Region } from '../country';
+export declare class Qualifier {
+    readonly id: string;
+    readonly iteration: Iteration;
+    readonly matches: QualifierMatch[];
+    readonly teams: Team[];
+    readonly status: StatusEnum;
+    readonly podium: Team[];
+    readonly region: Region;
+    champion?: Team;
+    static create(input: unknown): Qualifier;
+    private constructor();
+    static sortMatchesFn(m1: QualifierMatch, m2: QualifierMatch): number;
+}