volleyballsimtypes 0.0.122 → 0.0.124

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

@@ -4,16 +4,19 @@ exports.transformFromSeason = exports.transformToAPISeason = exports.transformTo
 const _1 = require(".");
 const service_1 = require("../../service");
 function transformToAttributes(season, leagueId) {
-    const matches = season.matches != null ?
-        season.matches.map((match, index) => (0, _1.transformFromSeasonMatch)(season.id, match, index)) : [];
+    const matches = season.matches != null
+        ? season.matches.map((match, index) => (0, _1.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;
+    const champion = season.champion != null
+        ? {
+            competition_id: season.id,
+            team_id: season.champion?.id
+        }
+        : undefined;
     return {
         competition_id: season.id,
         type: 'LEAGUE',
@@ -26,8 +29,9 @@ function transformToAttributes(season, leagueId) {
 }
 exports.transformFromSeason = transformToAttributes;
 function transformToObject(model) {
-    const matches = model.CompetitionMatches != null ?
-        model.CompetitionMatches.map(matches => (0, _1.transformToMatch)(matches.Match)) : [];
+    const matches = model.CompetitionMatches != null
+        ? model.CompetitionMatches.map(matches => (0, _1.transformToMatch)(matches.Match))
+        : [];
     return new service_1.Season({
         id: model.competition_id,
         matches,
@@ -39,31 +43,38 @@ function transformToObject(model) {
 exports.transformToSeason = transformToObject;
 function transformToAPIObject(model) {
     const season = transformToObject(model);
-    const matches = model.CompetitionMatches != null ?
-        model.CompetitionMatches.map(matches => (0, _1.transformToAPIMatch)(matches.Match)) : [];
+    const matches = model.CompetitionMatches != null
+        ? model.CompetitionMatches.map(matches => (0, _1.transformToAPIMatch)(matches.Match))
+        : [];
     const teams = model.Teams != null ? model.Teams.map(_1.transformToAPITeam) : [];
-    const standings = season.standings.map(standing => ({
-        team: teams.find(t => standing.team.id === t.id),
-        lost03: standing.lost03,
-        lost13: standing.lost13,
-        lost23: standing.lost23,
-        matchesLost: standing.matchesLost,
-        matchesWon: standing.matchesWon,
-        points: standing.points,
-        pointsLost: standing.pointsLost,
-        pointsRatio: standing.pointsRatio,
-        pointsWon: standing.pointsWon,
-        setsLost: standing.setsLost,
-        setsRatio: standing.setsRatio,
-        setsWon: standing.setsWon,
-        won30: standing.won30,
-        won31: standing.won31,
-        won32: standing.won32,
-        totalMatches: standing.totalMatches
-    }));
+    const standings = season.standings.map(standing => {
+        const team = teams.find(t => standing.team.id === t.id);
+        if (team == null) {
+            throw new Error('TEAM_NOT_FOUND');
+        }
+        return {
+            team,
+            lost03: standing.lost03,
+            lost13: standing.lost13,
+            lost23: standing.lost23,
+            matchesLost: standing.matchesLost,
+            matchesWon: standing.matchesWon,
+            points: standing.points,
+            pointsLost: standing.pointsLost,
+            pointsRatio: standing.pointsRatio,
+            pointsWon: standing.pointsWon,
+            setsLost: standing.setsLost,
+            setsRatio: standing.setsRatio,
+            setsWon: standing.setsWon,
+            won30: standing.won30,
+            won31: standing.won31,
+            won32: standing.won32,
+            totalMatches: standing.totalMatches
+        };
+    });
     return {
         id: model.competition_id,
-        matches: matches,
+        matches,
         iteration: model.iteration,
         league: model.LeagueSeason?.league != null ? (0, _1.transformToAPILeague)(model.LeagueSeason.league) : undefined,
         champion: model.CompetitionChampion != null ? (0, _1.transformToAPITeam)(model.CompetitionChampion.team) : undefined,

package/dist/cjs/src/data/transformers/serve.d.ts

@@ -1,7 +1,3 @@
-import { Serve } from '../../service';
-import { ServeAttributes, ServeModel } from '../models';
 import { APIServe } from '../../api';
-declare function transformToAttributes(event: Serve, rallyId: string): ServeAttributes;
-declare function transformToObject(serve: ServeModel): Serve;
-declare function transformToAPIObject(event: ServeModel): APIServe;
-export { transformToObject as transformToServe, transformToAPIObject as transformToAPIServe, transformToAttributes as transformFromServe };
+declare function transformToAPIObject(event: any): APIServe;
+export { transformToAPIObject as transformToAPIServe };

package/dist/cjs/src/data/transformers/serve.js

@@ -1,82 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformFromServe = exports.transformToAPIServe = exports.transformToServe = void 0;
-const service_1 = require("../../service");
-const _1 = require(".");
-function transformToServeFailure(failure) {
-    switch (failure) {
-        case service_1.ServeFailureEnum.NO_FAILURE:
-            return 'NO_FAILURE';
-        case service_1.ServeFailureEnum.FAULT:
-            return 'FAULT';
-        case service_1.ServeFailureEnum.MISS:
-            return 'MISS';
-        case service_1.ServeFailureEnum.OUT_OF_BOUNDS:
-            return 'OUT_OF_BOUNDS';
-        case service_1.ServeFailureEnum.NET:
-            return 'NET';
-        default:
-            throw new Error('UNKNOWN_ROLE');
-    }
-}
-function transformFromServeFailure(failure) {
-    return service_1.ServeFailureEnum[failure];
-}
-function transformToServeType(type) {
-    switch (type) {
-        case service_1.ServeTypeEnum.UNDERHAND:
-            return 'UNDERHAND';
-        case service_1.ServeTypeEnum.OVERHAND_TOPSPIN:
-            return 'OVERHAND_TOPSPIN';
-        case service_1.ServeTypeEnum.OVERHAND_FLOAT:
-            return 'OVERHAND_FLOAT';
-        case service_1.ServeTypeEnum.JUMP_TOPSPIN:
-            return 'JUMP_TOPSPIN';
-        case service_1.ServeTypeEnum.JUMP_FLOAT:
-            return 'JUMP_FLOAT';
-        default:
-            throw new Error('UNKNOWN_ROLE');
-    }
-}
-function transformFromServeType(type) {
-    return service_1.ServeTypeEnum[type];
-}
-function transformToAttributes(event, rallyId) {
-    return {
-        event_id: event.id,
-        player_id: event.player.id,
-        rally_id: rallyId,
-        order: event.order,
-        target: (0, _1.transformFromCourtTarget)(event.target),
-        failure: transformToServeFailure(event.failure),
-        type: transformToServeType(event.type),
-        event_type: (0, _1.transformFromEventType)(event.eventType),
-    };
-}
-exports.transformFromServe = transformToAttributes;
-function transformToObject(serve) {
-    return new service_1.Serve({
-        id: serve.event_id,
-        eventType: (0, _1.transformToEventType)(serve.event_type),
-        failure: transformFromServeFailure(serve.failure),
-        type: transformFromServeType(serve.type),
-        player: (0, _1.transformToPlayer)(serve.player),
-        target: (0, _1.transformToCourtTarget)(serve.target),
-        order: serve.order,
-        modifier: 1,
-        score: 1,
-        activeTraits: []
-    });
-}
-exports.transformToServe = transformToObject;
+exports.transformToAPIServe = void 0;
 function transformToAPIObject(event) {
     return {
-        id: event.event_id,
-        eventType: (0, _1.transformToEventType)(event.event_type),
-        failure: transformFromServeFailure(event.failure),
-        type: transformFromServeType(event.type),
-        playerId: event.player_id,
-        target: (0, _1.transformToCourtTarget)(event.target),
+        eventType: event.eventType,
+        failure: event.failure,
+        type: event.type,
+        playerId: event.player,
+        target: event.target,
         order: event.order
     };
 }

package/dist/cjs/src/data/transformers/set.d.ts

@@ -1,7 +1,3 @@
-import { Set } from '../../service';
-import { SetAttributes, SetModel } from '../models';
 import { APISet } from '../../api';
-declare function transformToAttributes(event: Set, rallyId: string): SetAttributes;
-declare function transformToObject(set: SetModel): Set;
-declare function transformToAPIObject(event: SetModel): APISet;
-export { transformToObject as transformToSet, transformToAPIObject as transformToAPISet, transformToAttributes as transformFromSet };
+declare function transformToAPIObject(event: any): APISet;
+export { transformToAPIObject as transformToAPISet };

package/dist/cjs/src/data/transformers/set.js

@@ -1,80 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformFromSet = exports.transformToAPISet = exports.transformToSet = void 0;
-const service_1 = require("../../service");
-const _1 = require(".");
-function transformToSetFailure(failure) {
-    switch (failure) {
-        case service_1.SetFailureEnum.NO_FAILURE:
-            return 'NO_FAILURE';
-        case service_1.SetFailureEnum.FAULT:
-            return 'FAULT';
-        case service_1.SetFailureEnum.MISS:
-            return 'MISS';
-        case service_1.SetFailureEnum.OUT_OF_BOUNDS:
-            return 'OUT_OF_BOUNDS';
-        case service_1.SetFailureEnum.BAD_PASS:
-            return 'BAD_PASS';
-        default:
-            throw new Error('UNKNOWN_ROLE');
-    }
-}
-function transformFromSetFailure(failure) {
-    return service_1.SetFailureEnum[failure];
-}
-function transformToSetType(type) {
-    switch (type) {
-        case service_1.SetTypeEnum.OVERHAND:
-            return 'OVERHAND';
-        case service_1.SetTypeEnum.UNDERHAND:
-            return 'UNDERHAND';
-        case service_1.SetTypeEnum.SPIKE:
-            return 'SPIKE';
-        case service_1.SetTypeEnum.DUMP:
-            return 'DUMP';
-        default:
-            throw new Error('UNKNOWN_ROLE');
-    }
-}
-function transformFromSetType(type) {
-    return service_1.SetTypeEnum[type];
-}
-function transformToAttributes(event, rallyId) {
-    return {
-        event_id: event.id,
-        player_id: event.player.id,
-        rally_id: rallyId,
-        order: event.order,
-        target: (0, _1.transformFromCourtTarget)(event.target),
-        failure: transformToSetFailure(event.failure),
-        type: transformToSetType(event.type),
-        event_type: (0, _1.transformFromEventType)(event.eventType)
-    };
-}
-exports.transformFromSet = transformToAttributes;
-function transformToObject(set) {
-    return new service_1.Set({
-        id: set.event_id,
-        eventType: (0, _1.transformToEventType)(set.event_type),
-        failure: transformFromSetFailure(set.failure),
-        type: transformFromSetType(set.type),
-        player: (0, _1.transformToPlayer)(set.player),
-        target: (0, _1.transformToCourtTarget)(set.target),
-        order: set.order,
-        modifier: 1,
-        score: 1,
-        activeTraits: []
-    });
-}
-exports.transformToSet = transformToObject;
+exports.transformToAPISet = void 0;
 function transformToAPIObject(event) {
     return {
-        id: event.event_id,
-        eventType: (0, _1.transformToEventType)(event.event_type),
-        failure: transformFromSetFailure(event.failure),
-        type: transformFromSetType(event.type),
-        playerId: event.player_id,
-        target: (0, _1.transformToCourtTarget)(event.target),
+        eventType: event.eventType,
+        failure: event.failure,
+        type: event.type,
+        playerId: event.player,
+        target: event.target,
         order: event.order
     };
 }

package/dist/cjs/src/data/transformers/spike.d.ts

@@ -1,7 +1,3 @@
-import { Spike } from '../../service';
-import { SpikeAttributes, SpikeModel } from '../models';
 import { APISpike } from '../../api';
-declare function transformToAttributes(event: Spike, rallyId: string): SpikeAttributes;
-declare function transformToObject(spike: SpikeModel): Spike;
-declare function transformToAPIObject(event: SpikeModel): APISpike;
-export { transformToObject as transformToSpike, transformToAPIObject as transformToAPISpike, transformToAttributes as transformFromSpike };
+declare function transformToAPIObject(event: any): APISpike;
+export { transformToAPIObject as transformToAPISpike };

package/dist/cjs/src/data/transformers/spike.js

@@ -1,85 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformFromSpike = exports.transformToAPISpike = exports.transformToSpike = void 0;
-const service_1 = require("../../service");
-const _1 = require(".");
-function transformToSpikeFailure(failure) {
-    switch (failure) {
-        case service_1.SpikeFailureEnum.NO_FAILURE:
-            return 'NO_FAILURE';
-        case service_1.SpikeFailureEnum.FAULT:
-            return 'FAULT';
-        case service_1.SpikeFailureEnum.MISS:
-            return 'MISS';
-        case service_1.SpikeFailureEnum.OUT_OF_BOUNDS:
-            return 'OUT_OF_BOUNDS';
-        case service_1.SpikeFailureEnum.NET:
-            return 'NET';
-        default:
-            throw new Error('UNKNOWN_ROLE');
-    }
-}
-function transformFromSpikeFailure(failure) {
-    return service_1.SpikeFailureEnum[failure];
-}
-function transformToSpikeType(type) {
-    switch (type) {
-        case service_1.SpikeTypeEnum.CROSS_SHOT:
-            return 'CROSS_SHOT';
-        case service_1.SpikeTypeEnum.LINE_SHOT:
-            return 'LINE_SHOT';
-        case service_1.SpikeTypeEnum.TOOL_SHOT:
-            return 'TOOL_SHOT';
-        case service_1.SpikeTypeEnum.TIP:
-            return 'TIP';
-        case service_1.SpikeTypeEnum.DOWN_BALL:
-            return 'DOWN_BALL';
-        case service_1.SpikeTypeEnum.OVERHAND:
-            return 'OVERHAND';
-        default:
-            throw new Error('UNKNOWN_ROLE');
-    }
-}
-function transformFromSpikeType(type) {
-    return service_1.SpikeTypeEnum[type];
-}
-function transformToAttributes(event, rallyId) {
-    return {
-        event_id: event.id,
-        player_id: event.player.id,
-        rally_id: rallyId,
-        order: event.order,
-        target: (0, _1.transformFromCourtTarget)(event.target),
-        failure: transformToSpikeFailure(event.failure),
-        type: transformToSpikeType(event.type),
-        event_type: (0, _1.transformFromEventType)(event.eventType)
-    };
-}
-exports.transformFromSpike = transformToAttributes;
-function transformToObject(spike) {
-    return new service_1.Spike({
-        id: spike.event_id,
-        eventType: (0, _1.transformToEventType)(spike.event_type),
-        failure: transformFromSpikeFailure(spike.failure),
-        type: transformFromSpikeType(spike.type),
-        player: (0, _1.transformToPlayer)(spike.player),
-        target: (0, _1.transformToCourtTarget)(spike.target),
-        order: spike.order,
-        modifier: 1,
-        score: 1,
-        activeTraits: []
-    });
-}
-exports.transformToSpike = transformToObject;
+exports.transformToAPISpike = void 0;
 function transformToAPIObject(event) {
     return {
-        id: event.event_id,
-        eventType: (0, _1.transformToEventType)(event.event_type),
-        failure: transformFromSpikeFailure(event.failure),
-        type: transformFromSpikeType(event.type),
-        playerId: event.player_id,
-        target: (0, _1.transformToCourtTarget)(event.target),
-        order: event.order,
+        eventType: event.eventType,
+        failure: event.failure,
+        type: event.type,
+        playerId: event.player,
+        target: event.target,
+        order: event.order
     };
 }
 exports.transformToAPISpike = transformToAPIObject;

package/dist/cjs/src/data/transformers/substitution.d.ts

@@ -1,7 +1,3 @@
-import { Substitution } from '../../service';
-import { SubstitutionAttributes, SubstitutionModel } from '../models';
 import { APISubstitution } from '../../api';
-declare function transformToAttributes(event: Substitution, rallyId: string): SubstitutionAttributes;
-declare function transformToObject(event: SubstitutionModel): Substitution;
-declare function transformToAPIObject(event: SubstitutionModel): APISubstitution;
-export { transformToObject as transformToSubstitution, transformToAPIObject as transformToAPISubstitution, transformToAttributes as transformFromSubstitution };
+declare function transformToAPIObject(event: any): APISubstitution;
+export { transformToAPIObject as transformToAPISubstitution };

package/dist/cjs/src/data/transformers/substitution.js

@@ -1,36 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformFromSubstitution = exports.transformToAPISubstitution = exports.transformToSubstitution = void 0;
-const service_1 = require("../../service");
-const _1 = require(".");
-function transformToAttributes(event, rallyId) {
-    return {
-        player_id: event.player.id,
-        event_id: event.id,
-        order: event.order,
-        event_type: (0, _1.transformFromEventType)(event.eventType),
-        player_out: event.playerOut.id,
-        rally_id: rallyId
-    };
-}
-exports.transformFromSubstitution = transformToAttributes;
-function transformToObject(event) {
-    return new service_1.Substitution({
-        id: event.event_id,
-        player: (0, _1.transformToPlayer)(event.player),
-        playerOut: (0, _1.transformToPlayer)(event.playerOut),
-        order: event.order,
-        eventType: (0, _1.transformToEventType)(event.event_type)
-    });
-}
-exports.transformToSubstitution = transformToObject;
+exports.transformToAPISubstitution = void 0;
 function transformToAPIObject(event) {
     return {
-        id: event.event_id,
-        eventType: (0, _1.transformToEventType)(event.event_type),
-        playerId: event.player_id,
+        eventType: event.eventType,
+        playerId: event.player,
         order: event.order,
-        playerOutId: event.player_out
+        playerOutId: event.playerOut
     };
 }
 exports.transformToAPISubstitution = transformToAPIObject;

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

@@ -21,9 +21,10 @@ function transformToObject(team) {
         id: team.team_id,
         name: team.name,
         shortName: team.short_name,
-        country: team.country != null ? (0, _1.transformToCountry)(team.country) : undefined,
-        coach: team.coach != null ? (0, _1.transformToCoach)(team.coach) : undefined,
-        roster: team.PlayerTeams != null ? team.PlayerTeams.map(pt => (0, _1.transformToPlayer)(pt.player)) : [],
+        country: (0, _1.transformToCountry)(team.country),
+        coach: (0, _1.transformToCoach)(team.coach),
+        roster: team.PlayerTeams.map(pt => (0, _1.transformToPlayer)(pt.player)),
+        league: (0, _1.transformToLeague)(team.league),
         rating: team.rating
     });
 }

package/dist/cjs/src/data/transformers/tournament.js

@@ -9,10 +9,12 @@ function transformToAttributes(tournament) {
         competition_id: tournament.id,
         team_id: team.id
     }));
-    const champion = tournament.champion != null ? {
-        competition_id: tournament.id,
-        team_id: tournament.champion?.id
-    } : undefined;
+    const champion = tournament.champion != null
+        ? {
+            competition_id: tournament.id,
+            team_id: tournament.champion?.id
+        }
+        : undefined;
     return {
         competition_id: tournament.id,
         type: 'TOURNAMENT',

package/dist/cjs/src/data/transformers/trait.js

@@ -32,6 +32,10 @@ function transformToAPIObject(model) {
 }
 exports.transformToAPITrait = transformToAPIObject;
 function transformToObject(model) {
-    return service_1.Trait.getTraits().find(trait => trait.id === model.trait_id);
+    const trait = service_1.Trait.getTraits().find(trait => trait.id === model.trait_id);
+    if (trait == null) {
+        throw new Error('TRAIT_NOT_FOUND');
+    }
+    return trait;
 }
 exports.transformToTrait = transformToObject;

package/dist/cjs/src/service/coach/coach.d.ts

@@ -6,14 +6,14 @@ interface CoachOpts {
     readonly name: Name;
     readonly country: Country;
     readonly formation: Formation;
-    readonly substitutionTolerance?: number;
+    readonly substitutionTolerance: number;
 }
 export declare class Coach {
     readonly id: string;
     readonly name: Name;
     readonly country: Country;
     readonly formation: Formation;
-    readonly substitutionTolerance?: number;
+    readonly substitutionTolerance: number;
     constructor({ id, name, country, formation, substitutionTolerance }: CoachOpts);
 }
 export {};

package/dist/cjs/src/service/event/block.d.ts

@@ -22,8 +22,9 @@ interface BlockOpts extends InPlayEventOpts {
 export declare class Block extends InPlayEvent {
     readonly failure: BlockFailureEnum;
     readonly type: BlockTypeEnum;
-    readonly blockers: Player[];
-    constructor({ id, order, score, player, target, failure, type, modifier, eventType, blockers, activeTraits }: BlockOpts);
+    readonly blockers: string[];
+    constructor({ order, score, player, target, failure, type, modifier, eventType, blockers, activeTraits }: BlockOpts);
     static getScore(blockers: Player[], modifier: number, activeTraits: Trait[]): number;
+    toString(): string;
 }
 export {};

package/dist/cjs/src/service/event/block.js

@@ -20,11 +20,11 @@ var BlockTypeEnum;
     BlockTypeEnum[BlockTypeEnum["TRIPLE"] = 3] = "TRIPLE";
 })(BlockTypeEnum = exports.BlockTypeEnum || (exports.BlockTypeEnum = {}));
 class Block extends in_play_event_1.InPlayEvent {
-    constructor({ id, order, score, player, target, failure, type, modifier, eventType, blockers, activeTraits }) {
-        super({ id, order, score, player, target, modifier, eventType, activeTraits });
+    constructor({ order, score, player, target, failure, type, modifier, eventType, blockers, activeTraits }) {
+        super({ order, score, player, target, modifier, eventType, activeTraits });
         this.type = type;
         this.failure = failure;
-        this.blockers = blockers;
+        this.blockers = blockers.map(b => b.id);
     }
     static getScore(blockers, modifier, activeTraits) {
         const type = blockers.length;
@@ -61,5 +61,8 @@ class Block extends in_play_event_1.InPlayEvent {
         }
         return score;
     }
+    toString() {
+        return `{order:${this.order},score:${this.order},player:${this.player},target:${this.target},failure:${this.failure},type:${this.type},modifier:${this.modifier},eventType:${this.eventType},blockers:[${this.blockers.join(',')}],activeTraits:[${this.activeTraits.join(',')}]}`;
+    }
 }
 exports.Block = Block;

package/dist/cjs/src/service/event/in-play-event.d.ts

@@ -13,7 +13,7 @@ export declare abstract class InPlayEvent extends RallyEvent {
     readonly target: CourtTargetEnum;
     readonly modifier: number;
     readonly score: number;
-    readonly activeTraits: Trait[];
-    protected constructor({ id, eventType, player, target, modifier, score, order, activeTraits }: InPlayEventOpts);
+    readonly activeTraits: string[];
+    protected constructor({ eventType, player, target, modifier, score, order, activeTraits }: InPlayEventOpts);
     protected static calculateScore(stats: PerformanceStats, eventType: string, type: string): number;
 }

package/dist/cjs/src/service/event/in-play-event.js

@@ -8,12 +8,12 @@ const rally_event_1 = require("./rally-event");
 const event_formula_json_1 = __importDefault(require("../../../data/event.formula.json"));
 const utils_1 = require("../utils");
 class InPlayEvent extends rally_event_1.RallyEvent {
-    constructor({ id, eventType, player, target, modifier, score, order, activeTraits }) {
-        super({ id, order, player, eventType });
+    constructor({ eventType, player, target, modifier, score, order, activeTraits }) {
+        super({ order, player, eventType });
         this.target = target;
         this.score = score;
         this.modifier = modifier;
-        this.activeTraits = activeTraits;
+        this.activeTraits = activeTraits.map(trait => trait.id);
     }
     static calculateScore(stats, eventType, type) {
         const weight = event_formula_json_1.default[eventType][type];

package/dist/cjs/src/service/event/libero-replacement.d.ts

@@ -11,7 +11,8 @@ export declare enum LiberoReplacementTypeEnum {
 }
 export declare class LiberoReplacement extends RallyEvent {
     readonly type: LiberoReplacementTypeEnum;
-    readonly libero: Player;
-    constructor({ id, order, player, type, libero, eventType }: LiberoReplacementOpts);
+    readonly libero: string;
+    constructor({ order, player, type, libero, eventType }: LiberoReplacementOpts);
+    toString(): string;
 }
 export {};

package/dist/cjs/src/service/event/libero-replacement.js

@@ -8,10 +8,13 @@ var LiberoReplacementTypeEnum;
     LiberoReplacementTypeEnum[LiberoReplacementTypeEnum["LIBERO_OUT"] = 1] = "LIBERO_OUT";
 })(LiberoReplacementTypeEnum = exports.LiberoReplacementTypeEnum || (exports.LiberoReplacementTypeEnum = {}));
 class LiberoReplacement extends rally_event_1.RallyEvent {
-    constructor({ id, order, player, type, libero, eventType }) {
-        super({ id, order, player, eventType });
+    constructor({ order, player, type, libero, eventType }) {
+        super({ order, player, eventType });
         this.type = type;
-        this.libero = libero;
+        this.libero = libero.id;
+    }
+    toString() {
+        return `{order:${this.order},player:${this.player},type:${this.type},eventType:${this.eventType},libero:${this.libero}}`;
     }
 }
 exports.LiberoReplacement = LiberoReplacement;

package/dist/cjs/src/service/event/rally-event.d.ts

@@ -9,15 +9,13 @@ export declare enum EventTypeEnum {
     BLOCK = 6
 }
 export interface RallyEventOpts {
-    readonly id: string;
     readonly player: Player;
     readonly eventType: EventTypeEnum;
     readonly order: number;
 }
 export declare abstract class RallyEvent {
-    readonly id: string;
     readonly order: number;
-    readonly player: Player;
+    readonly player: string;
     readonly eventType: EventTypeEnum;
-    protected constructor({ id, eventType, player, order }: RallyEventOpts);
+    protected constructor({ eventType, player, order }: RallyEventOpts);
 }

package/dist/cjs/src/service/event/rally-event.js

@@ -12,9 +12,8 @@ var EventTypeEnum;
     EventTypeEnum[EventTypeEnum["BLOCK"] = 6] = "BLOCK";
 })(EventTypeEnum = exports.EventTypeEnum || (exports.EventTypeEnum = {}));
 class RallyEvent {
-    constructor({ id, eventType, player, order }) {
-        this.id = id;
-        this.player = player;
+    constructor({ eventType, player, order }) {
+        this.player = player.id;
         this.order = order;
         this.eventType = eventType;
     }

package/dist/cjs/src/service/event/reception.d.ts

@@ -20,7 +20,8 @@ interface ReceptionOpts extends InPlayEventOpts {
 export declare class Reception extends InPlayEvent {
     readonly failure: ReceptionFailureEnum;
     readonly type: ReceptionTypeEnum;
-    constructor({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }: ReceptionOpts);
+    constructor({ order, score, player, target, failure, type, eventType, modifier, activeTraits }: ReceptionOpts);
     static getScore(stats: PerformanceStats, type: ReceptionTypeEnum, modifier: number, activeTraits: Trait[]): number;
+    toString(): string;
 }
 export {};