volleyballsimtypes 0.0.139 → 0.0.140

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

@@ -0,0 +1,17 @@
+interface CountryOpts {
+    readonly id: string;
+    readonly name: string;
+    readonly short: string;
+    readonly language?: string;
+    readonly league?: string;
+}
+export declare class Country {
+    readonly id: string;
+    readonly name: string;
+    readonly short: string;
+    readonly language?: string;
+    readonly league?: string;
+    constructor({ id, name, short, language, league }: CountryOpts);
+    toString(): string;
+}
+export {};

package/dist/esm/service/country/country.js

@@ -0,0 +1,18 @@
+export class Country {
+    constructor({ id, name, short, language, league }) {
+        this.id = id;
+        this.name = name;
+        this.short = short;
+        this.language = language;
+        this.league = league;
+    }
+    toString() {
+        return JSON.stringify({
+            id: this.id,
+            name: this.name,
+            short: this.short,
+            language: this.language,
+            league: this.league
+        });
+    }
+}

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

@@ -0,0 +1 @@
+export * from './country';

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

@@ -0,0 +1 @@
+export * from './country';

package/dist/esm/service/draft/draft-pick.d.ts

@@ -0,0 +1,14 @@
+import { Team } from '../team';
+import { Player } from '../player';
+interface DraftPickOpts {
+    readonly team: Team;
+    readonly pick: Player;
+    readonly priority: number;
+}
+export declare class DraftPick {
+    readonly team: Team;
+    readonly pick: Player;
+    readonly priority: number;
+    constructor({ team, pick, priority }: DraftPickOpts);
+}
+export {};

package/dist/esm/service/draft/draft-pick.js

@@ -0,0 +1,7 @@
+export class DraftPick {
+    constructor({ team, pick, priority }) {
+        this.team = team;
+        this.pick = pick;
+        this.priority = priority;
+    }
+}

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

@@ -0,0 +1,15 @@
+import { DraftPick } from './draft-pick';
+interface DraftParams {
+    readonly id: string;
+    readonly start: Date;
+    readonly end: Date;
+    readonly picks: DraftPick[];
+}
+export declare class Draft {
+    readonly id: string;
+    readonly start: Date;
+    readonly end: Date;
+    readonly picks: DraftPick[];
+    constructor({ id, start, end, picks }: DraftParams);
+}
+export {};

package/dist/esm/service/draft/draft.js

@@ -0,0 +1,8 @@
+export class Draft {
+    constructor({ id, start, end, picks }) {
+        this.id = id;
+        this.start = start;
+        this.end = end;
+        this.picks = picks;
+    }
+}

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

@@ -0,0 +1,2 @@
+export * from './draft';
+export * from './draft-pick';

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

@@ -0,0 +1,2 @@
+export * from './draft';
+export * from './draft-pick';

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

@@ -0,0 +1 @@
+export * from './rally-event';

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

@@ -0,0 +1 @@
+export * from './rally-event';

package/dist/esm/service/event/rally-event.d.ts

@@ -0,0 +1,20 @@
+import { Player } from '../player';
+export declare enum EventTypeEnum {
+    LIBERO_REPLACEMENT = 0,
+    SUBSTITUTION = 1,
+    SERVE = 2,
+    RECEPTION = 3,
+    SET = 4,
+    SPIKE = 5,
+    BLOCK = 6
+}
+export interface RallyEventOpts {
+    readonly player: Player;
+    readonly eventType: EventTypeEnum;
+}
+export declare abstract class RallyEvent {
+    readonly player: string;
+    readonly eventType: EventTypeEnum;
+    protected constructor({ eventType, player }: RallyEventOpts);
+    abstract toString(): string;
+}

package/dist/esm/service/event/rally-event.js

@@ -0,0 +1,16 @@
+export var EventTypeEnum;
+(function (EventTypeEnum) {
+    EventTypeEnum[EventTypeEnum["LIBERO_REPLACEMENT"] = 0] = "LIBERO_REPLACEMENT";
+    EventTypeEnum[EventTypeEnum["SUBSTITUTION"] = 1] = "SUBSTITUTION";
+    EventTypeEnum[EventTypeEnum["SERVE"] = 2] = "SERVE";
+    EventTypeEnum[EventTypeEnum["RECEPTION"] = 3] = "RECEPTION";
+    EventTypeEnum[EventTypeEnum["SET"] = 4] = "SET";
+    EventTypeEnum[EventTypeEnum["SPIKE"] = 5] = "SPIKE";
+    EventTypeEnum[EventTypeEnum["BLOCK"] = 6] = "BLOCK";
+})(EventTypeEnum || (EventTypeEnum = {}));
+export class RallyEvent {
+    constructor({ eventType, player }) {
+        this.player = player.id;
+        this.eventType = eventType;
+    }
+}

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

@@ -0,0 +1,9 @@
+export * from './match';
+export * from './coach';
+export * from './country';
+export * from './draft';
+export * from './team';
+export * from './event';
+export * from './player';
+export * from './competition';
+export * from './utils';

package/dist/esm/service/index.js

@@ -0,0 +1,9 @@
+export * from './match';
+export * from './coach';
+export * from './country';
+export * from './draft';
+export * from './team';
+export * from './event';
+export * from './player';
+export * from './competition';
+export * from './utils';

package/dist/esm/service/match/court-position.d.ts

@@ -0,0 +1,21 @@
+export declare enum CourtRow {
+    BACK = "BACK_ROW",
+    FRONT = "FRONT_ROW"
+}
+export declare enum CourtPosition {
+    NOT_IN_COURT = -1,
+    LIBERO_ZONE = 0,
+    LEFT_FRONT = 4,
+    MIDDLE_FRONT = 3,
+    RIGHT_FRONT = 2,
+    LEFT_BACK = 5,
+    MIDDLE_BACK = 6,
+    RIGHT_BACK = 1
+}
+export declare namespace CourtPosition {
+    function getPositions(): CourtPosition[];
+    function rotatePosition(position: number): CourtPosition;
+    function isFrontRow(position: number): boolean;
+    function isBackRow(position: number): boolean;
+    function getRow(row: CourtRow): CourtPosition[];
+}

package/dist/esm/service/match/court-position.js

@@ -0,0 +1,53 @@
+export var CourtRow;
+(function (CourtRow) {
+    CourtRow["BACK"] = "BACK_ROW";
+    CourtRow["FRONT"] = "FRONT_ROW";
+})(CourtRow || (CourtRow = {}));
+export var CourtPosition;
+(function (CourtPosition) {
+    CourtPosition[CourtPosition["NOT_IN_COURT"] = -1] = "NOT_IN_COURT";
+    CourtPosition[CourtPosition["LIBERO_ZONE"] = 0] = "LIBERO_ZONE";
+    // -----------------------------------------------------
+    CourtPosition[CourtPosition["LEFT_FRONT"] = 4] = "LEFT_FRONT";
+    CourtPosition[CourtPosition["MIDDLE_FRONT"] = 3] = "MIDDLE_FRONT";
+    CourtPosition[CourtPosition["RIGHT_FRONT"] = 2] = "RIGHT_FRONT";
+    CourtPosition[CourtPosition["LEFT_BACK"] = 5] = "LEFT_BACK";
+    CourtPosition[CourtPosition["MIDDLE_BACK"] = 6] = "MIDDLE_BACK";
+    CourtPosition[CourtPosition["RIGHT_BACK"] = 1] = "RIGHT_BACK";
+})(CourtPosition || (CourtPosition = {}));
+// eslint-disable-next-line @typescript-eslint/no-namespace
+(function (CourtPosition) {
+    const FRONT_ROW = [CourtPosition.LEFT_FRONT, CourtPosition.MIDDLE_FRONT, CourtPosition.RIGHT_FRONT];
+    const BACK_ROW = [CourtPosition.LEFT_BACK, CourtPosition.MIDDLE_BACK, CourtPosition.RIGHT_BACK];
+    function getPositions() {
+        return [...BACK_ROW, ...FRONT_ROW];
+    }
+    CourtPosition.getPositions = getPositions;
+    function rotatePosition(position) {
+        if (position < 1 || position > 6)
+            throw new Error('POSITION_INDEX_OUT_OF_BOUNDS');
+        if (position > CourtPosition.RIGHT_BACK)
+            return position - 1;
+        else
+            return CourtPosition.MIDDLE_BACK;
+    }
+    CourtPosition.rotatePosition = rotatePosition;
+    function isFrontRow(position) {
+        if (position < 1 || position > 6)
+            throw new Error('POSITION_INDEX_OUT_OF_BOUNDS');
+        return FRONT_ROW.includes(position);
+    }
+    CourtPosition.isFrontRow = isFrontRow;
+    function isBackRow(position) {
+        if (position < 1 || position > 6)
+            throw new Error(`POSITION_INDEX_OUT_OF_BOUNDS: ${position}`);
+        return BACK_ROW.includes(position);
+    }
+    CourtPosition.isBackRow = isBackRow;
+    function getRow(row) {
+        if (![CourtRow.BACK, CourtRow.FRONT].includes(row))
+            throw new Error(`INVALID_ROW: ${row}`);
+        return CourtRow.BACK === row ? [...BACK_ROW] : [...FRONT_ROW];
+    }
+    CourtPosition.getRow = getRow;
+})(CourtPosition || (CourtPosition = {}));

package/dist/esm/service/match/court-target-enum.d.ts

@@ -0,0 +1,21 @@
+import { CourtPosition, CourtRow } from './court-position';
+export declare enum CourtTargetEnum {
+    NO_TARGET = 0,
+    OPPONENT_RIGHT_BACK = 7,
+    OPPONENT_MIDDLE_BACK = 12,
+    OPPONENT_LEFT_BACK = 11,
+    OPPONENT_RIGHT_FRONT = 8,
+    OPPONENT_MIDDLE_FRONT = 9,
+    OPPONENT_LEFT_FRONT = 10,
+    TEAM_LEFT_FRONT = 4,
+    TEAM_MIDDLE_FRONT = 3,
+    TEAM_RIGHT_FRONT = 2,
+    TEAM_LEFT_BACK = 5,
+    TEAM_MIDDLE_BACK = 6,
+    TEAM_RIGHT_BACK = 1
+}
+export declare namespace CourtTargetEnum {
+    function getTeamSide(row?: CourtRow): CourtTargetEnum[];
+    function getOpponentSide(row?: CourtRow): CourtTargetEnum[];
+    function getSidePosition(position: number): CourtPosition;
+}

package/dist/esm/service/match/court-target-enum.js

@@ -0,0 +1,54 @@
+import { CourtRow } from './court-position';
+export var CourtTargetEnum;
+(function (CourtTargetEnum) {
+    CourtTargetEnum[CourtTargetEnum["NO_TARGET"] = 0] = "NO_TARGET";
+    CourtTargetEnum[CourtTargetEnum["OPPONENT_RIGHT_BACK"] = 7] = "OPPONENT_RIGHT_BACK";
+    CourtTargetEnum[CourtTargetEnum["OPPONENT_MIDDLE_BACK"] = 12] = "OPPONENT_MIDDLE_BACK";
+    CourtTargetEnum[CourtTargetEnum["OPPONENT_LEFT_BACK"] = 11] = "OPPONENT_LEFT_BACK";
+    CourtTargetEnum[CourtTargetEnum["OPPONENT_RIGHT_FRONT"] = 8] = "OPPONENT_RIGHT_FRONT";
+    CourtTargetEnum[CourtTargetEnum["OPPONENT_MIDDLE_FRONT"] = 9] = "OPPONENT_MIDDLE_FRONT";
+    CourtTargetEnum[CourtTargetEnum["OPPONENT_LEFT_FRONT"] = 10] = "OPPONENT_LEFT_FRONT";
+    // --------------------------------------------------------------------------------
+    CourtTargetEnum[CourtTargetEnum["TEAM_LEFT_FRONT"] = 4] = "TEAM_LEFT_FRONT";
+    CourtTargetEnum[CourtTargetEnum["TEAM_MIDDLE_FRONT"] = 3] = "TEAM_MIDDLE_FRONT";
+    CourtTargetEnum[CourtTargetEnum["TEAM_RIGHT_FRONT"] = 2] = "TEAM_RIGHT_FRONT";
+    CourtTargetEnum[CourtTargetEnum["TEAM_LEFT_BACK"] = 5] = "TEAM_LEFT_BACK";
+    CourtTargetEnum[CourtTargetEnum["TEAM_MIDDLE_BACK"] = 6] = "TEAM_MIDDLE_BACK";
+    CourtTargetEnum[CourtTargetEnum["TEAM_RIGHT_BACK"] = 1] = "TEAM_RIGHT_BACK";
+})(CourtTargetEnum || (CourtTargetEnum = {}));
+// eslint-disable-next-line @typescript-eslint/no-namespace
+(function (CourtTargetEnum) {
+    function getTeamSide(row) {
+        switch (true) {
+            case row === CourtRow.BACK:
+                return [CourtTargetEnum.TEAM_RIGHT_BACK, CourtTargetEnum.TEAM_MIDDLE_BACK, CourtTargetEnum.TEAM_LEFT_BACK];
+            case row === CourtRow.FRONT:
+                return [CourtTargetEnum.TEAM_RIGHT_FRONT, CourtTargetEnum.TEAM_MIDDLE_FRONT, CourtTargetEnum.TEAM_LEFT_FRONT];
+            default:
+                return [CourtTargetEnum.TEAM_RIGHT_BACK, CourtTargetEnum.TEAM_MIDDLE_BACK, CourtTargetEnum.TEAM_LEFT_BACK,
+                    CourtTargetEnum.TEAM_RIGHT_FRONT, CourtTargetEnum.TEAM_MIDDLE_FRONT, CourtTargetEnum.TEAM_LEFT_FRONT];
+        }
+    }
+    CourtTargetEnum.getTeamSide = getTeamSide;
+    function getOpponentSide(row) {
+        switch (true) {
+            case row === CourtRow.BACK:
+                return [CourtTargetEnum.OPPONENT_RIGHT_BACK, CourtTargetEnum.OPPONENT_MIDDLE_BACK, CourtTargetEnum.OPPONENT_LEFT_BACK];
+            case row === CourtRow.FRONT:
+                return [CourtTargetEnum.OPPONENT_RIGHT_FRONT, CourtTargetEnum.OPPONENT_MIDDLE_FRONT, CourtTargetEnum.OPPONENT_LEFT_FRONT];
+            default:
+                return [CourtTargetEnum.OPPONENT_RIGHT_BACK, CourtTargetEnum.OPPONENT_MIDDLE_BACK, CourtTargetEnum.OPPONENT_LEFT_BACK,
+                    CourtTargetEnum.OPPONENT_RIGHT_FRONT, CourtTargetEnum.OPPONENT_MIDDLE_FRONT, CourtTargetEnum.OPPONENT_LEFT_FRONT];
+        }
+    }
+    CourtTargetEnum.getOpponentSide = getOpponentSide;
+    function getSidePosition(position) {
+        if (position < 1 || position > 12)
+            throw new Error('POSITION_INDEX_OUT_OF_BOUNDS');
+        if (position > 6)
+            return position - 6;
+        else
+            return position;
+    }
+    CourtTargetEnum.getSidePosition = getSidePosition;
+})(CourtTargetEnum || (CourtTargetEnum = {}));

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

@@ -0,0 +1,7 @@
+export * from './match';
+export * from './match-rating';
+export * from './match-set';
+export * from './rally';
+export * from './court-position';
+export * from './court-target-enum';
+export * from './match-team';

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

@@ -0,0 +1,7 @@
+export * from './match';
+export * from './match-rating';
+export * from './match-set';
+export * from './rally';
+export * from './court-position';
+export * from './court-target-enum';
+export * from './match-team';

package/dist/esm/service/match/match-rating.d.ts

@@ -0,0 +1,35 @@
+import { Match, MatchTeam } from '.';
+import { CompetitionType } from '../../data';
+interface MatchRatingParams {
+    readonly match: Match;
+    readonly competitionType: CompetitionType;
+}
+interface SetScoreVariant {
+    '3-0': number;
+    '3-1': number;
+    '3-2': number;
+    '2-3': number;
+    '1-3': number;
+    '0-3': number;
+}
+interface MatchWeightFactor {
+    TOURNAMENT: number;
+    LEAGUE: number;
+}
+export declare class MatchRating {
+    static K: number;
+    static SSV: SetScoreVariant;
+    static C1: number;
+    static C2: number;
+    static C3: number;
+    static C4: number;
+    static C5: number;
+    static MWF: MatchWeightFactor;
+    readonly match: Match;
+    readonly weight: number;
+    constructor({ match, competitionType }: MatchRatingParams);
+    getPoints(team: MatchTeam): number;
+    static calculateProbability(z: number): number;
+    getExpectedResult(): number;
+}
+export {};

package/dist/esm/service/match/match-rating.js

@@ -0,0 +1,61 @@
+import { MatchScore } from '.';
+export class MatchRating {
+    constructor({ match, competitionType }) {
+        this.match = match;
+        this.weight = MatchRating.MWF[competitionType];
+    }
+    getPoints(team) {
+        const rankingValue = MatchRating.SSV[this.match.getScore()] - this.getExpectedResult();
+        const weighted = rankingValue * this.weight / MatchRating.K;
+        if (this.match.isWinner(team))
+            return weighted;
+        else
+            return weighted * -1;
+    }
+    static calculateProbability(z) {
+        let area = 0.0;
+        const rectangles = 100000;
+        const width = (z - (-10)) / rectangles;
+        for (let i = 0; i < rectangles; i++) {
+            area += width * Math.exp(-Math.pow((width * i + (-10)), 2) / 2) / Math.sqrt(2 * Math.PI);
+        }
+        return area;
+    }
+    getExpectedResult() {
+        const D = MatchRating.K * (this.match.homeTeam.rating - this.match.awayTeam.rating) / 1000; // Strength difference between the teams
+        const P1 = MatchRating.calculateProbability(MatchRating.C1 + D); // 3-0
+        const P2 = MatchRating.calculateProbability(MatchRating.C2 + D) -
+            MatchRating.calculateProbability(MatchRating.C1 + D); // 3-1
+        const P3 = MatchRating.calculateProbability(MatchRating.C3 + D) -
+            MatchRating.calculateProbability(MatchRating.C2 + D); // 3-2
+        const P4 = MatchRating.calculateProbability(MatchRating.C4 + D) -
+            MatchRating.calculateProbability(MatchRating.C3 + D); // 2-3
+        const P5 = MatchRating.calculateProbability(MatchRating.C5 + D) -
+            MatchRating.calculateProbability(MatchRating.C4 + D); // 1-3
+        const P6 = 1 - MatchRating.calculateProbability(MatchRating.C5 + D); // 0-3
+        return P1 * MatchRating.SSV['3-0'] +
+            P2 * MatchRating.SSV['3-1'] +
+            P3 * MatchRating.SSV['3-2'] +
+            P4 * MatchRating.SSV['2-3'] +
+            P5 * MatchRating.SSV['1-3'] +
+            P6 * MatchRating.SSV['0-3']; // Expected Match Result EMR
+    }
+}
+MatchRating.K = 8; // Standard scaling factor
+MatchRating.SSV = {
+    [MatchScore['3-0']]: 2,
+    [MatchScore['3-1']]: 1.5,
+    [MatchScore['3-2']]: 1,
+    [MatchScore['2-3']]: -1,
+    [MatchScore['1-3']]: -1.5,
+    [MatchScore['0-3']]: -2
+};
+MatchRating.C1 = -1.060;
+MatchRating.C2 = -0.394;
+MatchRating.C3 = 0;
+MatchRating.C4 = 0.394;
+MatchRating.C5 = 1.060;
+MatchRating.MWF = {
+    TOURNAMENT: 50,
+    LEAGUE: 35
+};

package/dist/esm/service/match/match-set.d.ts

@@ -0,0 +1,65 @@
+import { PlayerPosition, Rally } from './rally';
+import { MatchTeam } from './match-team';
+import { Player } from '../player';
+declare enum ScoreThreshold {
+    SET = 25,
+    TIE_BREAK = 15
+}
+interface MatchSetParams {
+    readonly id: string;
+    readonly order: number;
+    readonly isTieBreak: boolean;
+    readonly homePlayerPosition: PlayerPosition[];
+    readonly awayPlayerPosition: PlayerPosition[];
+    readonly homeScore: number;
+    readonly awayScore: number;
+    readonly stats: SetStatistics[];
+    readonly rallies: Rally[];
+}
+export interface EventStat {
+    success: number;
+    error: number;
+}
+export interface SetStatistics {
+    player: Player;
+    ace: number;
+    attempts: number;
+    contacts: number;
+    ralliesPlayed: number;
+    serve: EventStat;
+    reception: EventStat;
+    set: EventStat;
+    attack: EventStat;
+    block: EventStat;
+    kills: number;
+    killBlocks: number;
+    assists: number;
+}
+export declare class MatchSet {
+    readonly id: string;
+    readonly order: number;
+    readonly isTieBreak: boolean;
+    readonly homePlayerPosition: PlayerPosition[];
+    readonly awayPlayerPosition: PlayerPosition[];
+    readonly stats: SetStatistics[];
+    readonly rallies: Rally[];
+    readonly scoreThreshold: ScoreThreshold;
+    private _homeScore;
+    private _awayScore;
+    constructor({ id, order, isTieBreak, homePlayerPosition, awayPlayerPosition, stats, rallies, homeScore, awayScore }: MatchSetParams);
+    get homeScore(): number;
+    get awayScore(): number;
+    increaseScore(team: MatchTeam): void;
+    addRally(rally: Rally): void;
+    /**
+     * Has a team reached at least 25 points and is the score difference between both teams at least 2?
+     * @returns boolean
+     */
+    isOver(): boolean;
+    /**
+     * Get the team that won the Set. Return undefined if set is not over.
+     * @returns CourtTeam
+     */
+    getWinner(): MatchTeam;
+}
+export {};

package/dist/esm/service/match/match-set.js

@@ -0,0 +1,56 @@
+import { validateUUID } from '../utils';
+import { MatchTeam } from './match-team';
+var ScoreThreshold;
+(function (ScoreThreshold) {
+    ScoreThreshold[ScoreThreshold["SET"] = 25] = "SET";
+    ScoreThreshold[ScoreThreshold["TIE_BREAK"] = 15] = "TIE_BREAK";
+})(ScoreThreshold || (ScoreThreshold = {}));
+export class MatchSet {
+    constructor({ id, order, isTieBreak, homePlayerPosition, awayPlayerPosition, stats, rallies, homeScore, awayScore }) {
+        validateUUID(id);
+        this.id = id;
+        this.order = order;
+        this._homeScore = homeScore;
+        this._awayScore = awayScore;
+        this.homePlayerPosition = homePlayerPosition;
+        this.awayPlayerPosition = awayPlayerPosition;
+        this.stats = stats;
+        this.rallies = rallies;
+        this.isTieBreak = isTieBreak;
+        this.scoreThreshold = isTieBreak ? ScoreThreshold.TIE_BREAK : ScoreThreshold.SET;
+    }
+    get homeScore() {
+        return this._homeScore;
+    }
+    get awayScore() {
+        return this._awayScore;
+    }
+    increaseScore(team) {
+        if (team === MatchTeam.HOME)
+            this._homeScore++;
+        else if (team === MatchTeam.AWAY)
+            this._awayScore++;
+        else
+            throw new Error('UNKNOWN_TEAM');
+    }
+    addRally(rally) {
+        this.rallies.push(rally);
+    }
+    /**
+     * Has a team reached at least 25 points and is the score difference between both teams at least 2?
+     * @returns boolean
+     */
+    isOver() {
+        return Math.abs(this.homeScore - this.awayScore) > 1 &&
+            (this.homeScore >= this.scoreThreshold || this.awayScore >= this.scoreThreshold);
+    }
+    /**
+     * Get the team that won the Set. Return undefined if set is not over.
+     * @returns CourtTeam
+     */
+    getWinner() {
+        if (!this.isOver())
+            throw new Error('UNFINISHED_SET');
+        return this.homeScore > this.awayScore ? MatchTeam.HOME : MatchTeam.AWAY;
+    }
+}

package/dist/esm/service/match/match-team.d.ts

@@ -0,0 +1,7 @@
+export declare enum MatchTeam {
+    HOME = "homeTeam",
+    AWAY = "awayTeam"
+}
+export declare namespace MatchTeam {
+    function otherTeam(team: MatchTeam): MatchTeam;
+}

package/dist/esm/service/match/match-team.js

@@ -0,0 +1,17 @@
+export var MatchTeam;
+(function (MatchTeam) {
+    MatchTeam["HOME"] = "homeTeam";
+    MatchTeam["AWAY"] = "awayTeam";
+})(MatchTeam || (MatchTeam = {}));
+// eslint-disable-next-line @typescript-eslint/no-namespace
+(function (MatchTeam) {
+    function otherTeam(team) {
+        if (team === MatchTeam.HOME)
+            return MatchTeam.AWAY;
+        else if (team === MatchTeam.AWAY)
+            return MatchTeam.HOME;
+        else
+            throw new Error('UNKNOWN_MATCH_TEAM');
+    }
+    MatchTeam.otherTeam = otherTeam;
+})(MatchTeam || (MatchTeam = {}));

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

@@ -0,0 +1,36 @@
+import { MatchSet } from './match-set';
+import { Team } from '../team';
+import { MatchTeam } from './match-team';
+interface MatchParams {
+    readonly id: string;
+    readonly homeTeam: Team;
+    readonly awayTeam: Team;
+    readonly scheduledDate: Date;
+    readonly sets: MatchSet[];
+    readonly isSimulated: boolean;
+}
+export declare enum MatchScore {
+    '3-0' = "3-0",
+    '3-1' = "3-1",
+    '3-2' = "3-2",
+    '2-3' = "2-3",
+    '1-3' = "1-3",
+    '0-3' = "0-3"
+}
+export declare class Match {
+    static readonly BEST_OF = 5;
+    readonly id: string;
+    readonly homeTeam: Team;
+    readonly awayTeam: Team;
+    readonly sets: MatchSet[];
+    readonly scheduledDate: Date;
+    isSimulated: boolean;
+    constructor({ id, homeTeam, awayTeam, scheduledDate, sets, isSimulated }: MatchParams);
+    addSet(set: MatchSet): void;
+    getTeamSets(team: MatchTeam): number;
+    getScore(): MatchScore;
+    isOver(): boolean;
+    getWinner(): Team;
+    isWinner(team: MatchTeam): boolean;
+}
+export {};