volleyballsimtypes 0.0.121 → 0.0.123

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/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;
+    protected 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);
+    protected 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;
+    protected toString(): string;
 }
 export {};

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

@@ -19,8 +19,8 @@ var ReceptionFailureEnum;
     ReceptionFailureEnum[ReceptionFailureEnum["BAD_PASS"] = 4] = "BAD_PASS";
 })(ReceptionFailureEnum = exports.ReceptionFailureEnum || (exports.ReceptionFailureEnum = {}));
 class Reception extends in_play_event_1.InPlayEvent {
-    constructor({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }) {
-        super({ id, order, score, player, target, eventType, modifier, activeTraits });
+    constructor({ order, score, player, target, failure, type, eventType, modifier, activeTraits }) {
+        super({ order, score, player, target, eventType, modifier, activeTraits });
         this.type = type;
         this.failure = failure;
     }
@@ -36,5 +36,8 @@ class Reception 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},activeTraits:[${this.activeTraits.join(',')}]}`;
+    }
 }
 exports.Reception = Reception;

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

@@ -21,7 +21,8 @@ interface ServeOpts extends InPlayEventOpts {
 export declare class Serve extends InPlayEvent {
     readonly failure: ServeFailureEnum;
     readonly type: ServeTypeEnum;
-    constructor({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }: ServeOpts);
+    constructor({ order, score, player, target, failure, type, eventType, modifier, activeTraits }: ServeOpts);
     static getScore(stats: PerformanceStats, type: ServeTypeEnum, modifier: number, activeTraits: Trait[]): number;
+    protected toString(): string;
 }
 export {};

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

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Serve = exports.ServeFailureEnum = exports.ServeTypeEnum = void 0;
 const in_play_event_1 = require("./in-play-event");
-const player_1 = require("../player");
 var ServeTypeEnum;
 (function (ServeTypeEnum) {
     ServeTypeEnum[ServeTypeEnum["UNDERHAND"] = 0] = "UNDERHAND";
@@ -20,22 +19,20 @@ var ServeFailureEnum;
     ServeFailureEnum[ServeFailureEnum["OUT_OF_BOUNDS"] = 4] = "OUT_OF_BOUNDS";
 })(ServeFailureEnum = exports.ServeFailureEnum || (exports.ServeFailureEnum = {}));
 class Serve extends in_play_event_1.InPlayEvent {
-    constructor({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }) {
-        super({ id, order, score, player, target, eventType, modifier, activeTraits });
+    constructor({ order, score, player, target, failure, type, eventType, modifier, activeTraits }) {
+        super({ order, score, player, target, eventType, modifier, activeTraits });
         this.type = type;
         this.failure = failure;
     }
     static getScore(stats, type, modifier, activeTraits) {
         let score = Serve.calculateScore(stats, 'SERVE', ServeTypeEnum[type]) * modifier;
         for (const trait of activeTraits) {
-            switch (true) {
-                case trait === player_1.Trait.METEOR_SERVE: {
-                    score *= player_1.Trait.METEOR_SERVE.modifier;
-                    break;
-                }
-            }
+            score *= trait.modifier;
         }
         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},activeTraits:[${this.activeTraits.join(',')}]}`;
+    }
 }
 exports.Serve = Serve;

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

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

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

@@ -19,8 +19,8 @@ var SetFailureEnum;
     SetFailureEnum[SetFailureEnum["OUT_OF_BOUNDS"] = 4] = "OUT_OF_BOUNDS";
 })(SetFailureEnum = exports.SetFailureEnum || (exports.SetFailureEnum = {}));
 class Set extends in_play_event_1.InPlayEvent {
-    constructor({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }) {
-        super({ id, order, score, player, target, eventType, modifier, activeTraits });
+    constructor({ order, score, player, target, failure, type, eventType, modifier, activeTraits }) {
+        super({ order, score, player, target, eventType, modifier, activeTraits });
         this.type = type;
         this.failure = failure;
     }
@@ -41,5 +41,8 @@ class Set 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},activeTraits:[${this.activeTraits.join(',')}]}`;
+    }
 }
 exports.Set = Set;

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

@@ -22,7 +22,8 @@ interface SpikeOpts extends InPlayEventOpts {
 export declare class Spike extends InPlayEvent {
     readonly failure: SpikeFailureEnum;
     readonly type: SpikeTypeEnum;
-    constructor({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }: SpikeOpts);
+    constructor({ order, score, player, target, failure, type, eventType, modifier, activeTraits }: SpikeOpts);
     static getScore(player: Player, type: SpikeTypeEnum, modifier: number, isBackRow: boolean, activeTraits: Trait[]): number;
+    protected toString(): string;
 }
 export {};

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

@@ -21,8 +21,8 @@ var SpikeFailureEnum;
     SpikeFailureEnum[SpikeFailureEnum["NET"] = 4] = "NET";
 })(SpikeFailureEnum = exports.SpikeFailureEnum || (exports.SpikeFailureEnum = {}));
 class Spike extends in_play_event_1.InPlayEvent {
-    constructor({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }) {
-        super({ id, order, score, player, target, eventType, modifier, activeTraits });
+    constructor({ order, score, player, target, failure, type, eventType, modifier, activeTraits }) {
+        super({ order, score, player, target, eventType, modifier, activeTraits });
         this.type = type;
         this.failure = failure;
     }
@@ -46,5 +46,8 @@ class Spike 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},activeTraits:[${this.activeTraits.join(',')}]}`;
+    }
 }
 exports.Spike = Spike;

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

@@ -4,7 +4,8 @@ interface SubstitutionOpts extends RallyEventOpts {
     readonly playerOut: Player;
 }
 export declare class Substitution extends RallyEvent {
-    readonly playerOut: Player;
-    constructor({ id, order, playerOut, player, eventType }: SubstitutionOpts);
+    readonly playerOut: string;
+    constructor({ order, playerOut, player, eventType }: SubstitutionOpts);
+    protected toString(): string;
 }
 export {};

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

@@ -3,9 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Substitution = void 0;
 const rally_event_1 = require("./rally-event");
 class Substitution extends rally_event_1.RallyEvent {
-    constructor({ id, order, playerOut, player, eventType }) {
-        super({ eventType, player, order, id });
-        this.playerOut = playerOut;
+    constructor({ order, playerOut, player, eventType }) {
+        super({ eventType, player, order });
+        this.playerOut = playerOut.id;
+    }
+    toString() {
+        return `{order:${this.order},score:${this.order},player:${this.player},playerOut:${this.playerOut},eventType:${this.eventType}}`;
     }
 }
 exports.Substitution = Substitution;

package/dist/cjs/src/service/player/role.js

@@ -26,10 +26,10 @@ class Role {
             score: this.calculateScore(stats, role)
         })).sort((x, y) => y.score - x.score);
         const out = [scores[0].role];
-        if (scores[1].score >= 65) {
+        if (scores[1].score >= 75) {
             out.push(scores[1].role);
         }
-        if (scores[2].score >= 70) {
+        if (scores[2].score >= 85) {
             out.push(scores[2].role);
         }
         return out;

package/dist/cjs/src/service/player/trait.js

@@ -22,13 +22,13 @@ class Trait {
         const random = Math.random();
         let traitCount;
         switch (true) {
-            case random > 0.9:
+            case random > 0.95:
                 traitCount = 3;
                 break;
-            case random > 0.75:
+            case random > 0.85:
                 traitCount = 2;
                 break;
-            case random > 0.4:
+            case random > 0.6:
                 traitCount = 1;
                 break;
             default:

package/dist/esm/src/api/events.d.ts

@@ -1,7 +1,6 @@
 import { BlockFailureEnum, BlockTypeEnum, CourtTargetEnum, EventTypeEnum, LiberoReplacementTypeEnum, ReceptionFailureEnum, ReceptionTypeEnum, ServeFailureEnum, ServeTypeEnum, SetFailureEnum, SetTypeEnum, SpikeFailureEnum, SpikeTypeEnum } from '../service';
 import { APITeam } from './team';
 export interface APIEvent {
-    readonly id: string;
     readonly order: number;
     readonly playerId: string;
     readonly eventType: EventTypeEnum;

package/dist/esm/src/data/init-models.d.ts

@@ -1,7 +1,6 @@
 import type { Sequelize } from 'sequelize';
-import { BlockModel, CoachModel, CompetitionChampionModel, CompetitionMatchModel, CompetitionModel, CompetitionTeamsModel, CountryModel, DraftModel, DraftPickModel, EventModel, IterationModel, LeagueModel, LeagueSeasonModel, LiberoReplacementModel, MatchModel, MatchRatingModel, MatchSetModel, MatchSetStatsModel, PerformanceStatsModel, PlayerModel, PlayerTeamModel, PlayerTraitModel, RallyModel, ReceptionModel, ServeModel, SetModel, SetPositionModel, SpikeModel, SubstitutionModel, TeamModel, TraitModel, UserModel } from './models';
+import { CoachModel, CompetitionChampionModel, CompetitionMatchModel, CompetitionModel, CompetitionTeamsModel, CountryModel, DraftModel, DraftPickModel, IterationModel, LeagueModel, LeagueSeasonModel, MatchModel, MatchRatingModel, MatchSetModel, MatchSetStatsModel, PerformanceStatsModel, PlayerModel, PlayerTeamModel, PlayerTraitModel, RallyModel, SetPositionModel, TeamModel, TraitModel, UserModel } from './models';
 export declare function initModels(sequelize: Sequelize): {
-    Block: typeof BlockModel;
     Coach: typeof CoachModel;
     Competition: typeof CompetitionModel;
     CompetitionChampion: typeof CompetitionChampionModel;
@@ -10,11 +9,17 @@ export declare function initModels(sequelize: Sequelize): {
     Country: typeof CountryModel;
     Draft: typeof DraftModel;
     DraftPick: typeof DraftPickModel;
-    Event: typeof EventModel;
+    Event: {
+        new (type: string, eventInitDict?: EventInit | undefined): Event;
+        prototype: Event;
+        readonly AT_TARGET: number;
+        readonly BUBBLING_PHASE: number;
+        readonly CAPTURING_PHASE: number;
+        readonly NONE: number;
+    };
     Iteration: typeof IterationModel;
     League: typeof LeagueModel;
     LeagueSeason: typeof LeagueSeasonModel;
-    LiberoReplacement: typeof LiberoReplacementModel;
     Match: typeof MatchModel;
     MatchRating: typeof MatchRatingModel;
     MatchSet: typeof MatchSetModel;
@@ -24,12 +29,7 @@ export declare function initModels(sequelize: Sequelize): {
     PlayerTeam: typeof PlayerTeamModel;
     PlayerTrait: typeof PlayerTraitModel;
     Rally: typeof RallyModel;
-    Reception: typeof ReceptionModel;
-    Serve: typeof ServeModel;
-    Set: typeof SetModel;
     SetPosition: typeof SetPositionModel;
-    Spike: typeof SpikeModel;
-    Substitution: typeof SubstitutionModel;
     Team: typeof TeamModel;
     Trait: typeof TraitModel;
     User: typeof UserModel;