volleyballsimtypes 0.0.122 → 0.0.124

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;
+    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;
+    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;
+    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);
+    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/team/team.d.ts

@@ -8,18 +8,18 @@ interface TeamOpts {
     readonly name: string;
     readonly shortName: string;
     readonly roster: Player[];
-    readonly country?: Country;
-    readonly league?: League;
-    readonly coach?: Coach;
+    readonly country: Country;
+    readonly league: League;
+    readonly coach: Coach;
 }
 export declare class Team {
     readonly id: string;
     readonly roster: Player[];
     readonly name: string;
     readonly shortName: string;
-    readonly coach?: Coach;
-    readonly league?: League;
-    readonly country?: Country;
+    readonly coach: Coach;
+    readonly league: League;
+    readonly country: Country;
     private _rating;
     constructor({ id, rating, name, shortName, country, roster, coach, league }: TeamOpts);
     get rating(): number;

package/dist/cjs/src/service/team/team.js

@@ -25,6 +25,9 @@ class Team {
         return this.roster.some(p => p.id === player.id);
     }
     toString() {
+        if (this.country == null) {
+            throw new Error('UNKNOWN_COUNTRY');
+        }
         return `${this.name} [${this.shortName}] (${this.country?.name}) ELO=${this._rating}`;
     }
     updateRating(ratingChange) {

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,36 +1,2 @@
 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';
-export declare function initModels(sequelize: Sequelize): {
-    Block: typeof BlockModel;
-    Coach: typeof CoachModel;
-    Competition: typeof CompetitionModel;
-    CompetitionChampion: typeof CompetitionChampionModel;
-    CompetitionMatch: typeof CompetitionMatchModel;
-    CompetitionTeams: typeof CompetitionTeamsModel;
-    Country: typeof CountryModel;
-    Draft: typeof DraftModel;
-    DraftPick: typeof DraftPickModel;
-    Event: typeof EventModel;
-    Iteration: typeof IterationModel;
-    League: typeof LeagueModel;
-    LeagueSeason: typeof LeagueSeasonModel;
-    LiberoReplacement: typeof LiberoReplacementModel;
-    Match: typeof MatchModel;
-    MatchRating: typeof MatchRatingModel;
-    MatchSet: typeof MatchSetModel;
-    MatchSetStats: typeof MatchSetStatsModel;
-    PerformanceStats: typeof PerformanceStatsModel;
-    Player: typeof PlayerModel;
-    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;
-};
+export declare function initModels(sequelize: Sequelize): any;

package/dist/esm/src/data/init-models.js

@@ -1,6 +1,5 @@
-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 function initModels(sequelize) {
-    const Block = BlockModel.initModel(sequelize);
     const Coach = CoachModel.initModel(sequelize);
     const Country = CountryModel.initModel(sequelize);
     const Competition = CompetitionModel.initModel(sequelize);
@@ -9,11 +8,9 @@ export function initModels(sequelize) {
     const CompetitionMatch = CompetitionMatchModel.initModel(sequelize);
     const Draft = DraftModel.initModel(sequelize);
     const DraftPick = DraftPickModel.initModel(sequelize);
-    const Event = EventModel.initModel(sequelize);
     const Iteration = IterationModel.initModel(sequelize);
     const League = LeagueModel.initModel(sequelize);
     const LeagueSeason = LeagueSeasonModel.initModel(sequelize);
-    const LiberoReplacement = LiberoReplacementModel.initModel(sequelize);
     const Match = MatchModel.initModel(sequelize);
     const MatchRating = MatchRatingModel.initModel(sequelize);
     const MatchSet = MatchSetModel.initModel(sequelize);
@@ -24,19 +21,9 @@ export function initModels(sequelize) {
     const PlayerTrait = PlayerTraitModel.initModel(sequelize);
     const Rally = RallyModel.initModel(sequelize);
     const SetPosition = SetPositionModel.initModel(sequelize);
-    const Reception = ReceptionModel.initModel(sequelize);
-    const Serve = ServeModel.initModel(sequelize);
-    const Set = SetModel.initModel(sequelize);
-    const Spike = SpikeModel.initModel(sequelize);
-    const Substitution = SubstitutionModel.initModel(sequelize);
     const Team = TeamModel.initModel(sequelize);
     const Trait = TraitModel.initModel(sequelize);
     const User = UserModel.initModel(sequelize);
-    Block.belongsTo(Player, { as: 'Blocker_1', foreignKey: 'blocker_1' });
-    Block.belongsTo(Player, { as: 'Blocker_2', foreignKey: 'blocker_2' });
-    Block.belongsTo(Player, { as: 'Blocker_3', foreignKey: 'blocker_3' });
-    Block.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
-    Block.belongsTo(Rally, { as: 'rally', foreignKey: 'rally_id' });
     Coach.belongsTo(Country, { as: 'country', foreignKey: 'country_id' });
     Coach.hasMany(Team, { as: 'Teams', foreignKey: 'coach_id' });
     Competition.belongsTo(Iteration, { as: 'Iteration', foreignKey: 'iteration' });
@@ -64,17 +51,12 @@ export function initModels(sequelize) {
     DraftPick.belongsTo(Draft, { as: 'draft', foreignKey: 'draft_id' });
     DraftPick.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
     DraftPick.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
-    Event.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
-    Event.belongsTo(Rally, { as: 'rally', foreignKey: 'rally_id' });
     Iteration.hasMany(Competition, { as: 'Competitions', foreignKey: 'iteration' });
     League.belongsTo(Country, { as: 'country', foreignKey: 'country_id' });
     League.hasMany(LeagueSeason, { as: 'LeagueSeasons', foreignKey: 'league_id' });
     League.hasMany(Team, { as: 'Teams', foreignKey: 'league_id' });
     LeagueSeason.belongsTo(Competition, { as: 'competition', foreignKey: 'competition_id' });
     LeagueSeason.belongsTo(League, { as: 'league', foreignKey: 'league_id' });
-    LiberoReplacement.belongsTo(Player, { as: 'Libero', foreignKey: 'libero' });
-    LiberoReplacement.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
-    LiberoReplacement.belongsTo(Rally, { as: 'rally', foreignKey: 'rally_id' });
     Match.belongsTo(Team, { as: 'AwayTeam', foreignKey: 'away_team' });
     Match.belongsTo(Team, { as: 'HomeTeam', foreignKey: 'home_team' });
     Match.belongsToMany(Team, {
@@ -132,23 +114,10 @@ export function initModels(sequelize) {
         foreignKey: 'player_id',
         otherKey: 'trait_id'
     });
-    Player.hasMany(Block, { as: 'Blocks', foreignKey: 'player_id' });
-    Player.hasMany(Block, { as: 'blocker_1_Blocks', foreignKey: 'blocker_1' });
-    Player.hasMany(Block, { as: 'blocker_2_Blocks', foreignKey: 'blocker_2' });
-    Player.hasMany(Block, { as: 'blocker_3_Blocks', foreignKey: 'blocker_3' });
-    Player.hasMany(Event, { as: 'Events', foreignKey: 'player_id' });
-    Player.hasMany(LiberoReplacement, { as: 'LiberoReplacements', foreignKey: 'libero' });
-    Player.hasMany(LiberoReplacement, { as: 'player_LiberoReplacements', foreignKey: 'player_id' });
     Player.hasMany(MatchSetStats, { as: 'MatchSetStats', foreignKey: 'player_id' });
     Player.hasMany(PlayerTeam, { as: 'PlayerTeams', foreignKey: 'player_id' });
     Player.hasMany(PlayerTrait, { as: 'PlayerTraits', foreignKey: 'player_id' });
-    Player.hasMany(Reception, { as: 'Receptions', foreignKey: 'player_id' });
-    Player.hasMany(Serve, { as: 'Serves', foreignKey: 'player_id' });
-    Player.hasMany(Set, { as: 'Sets', foreignKey: 'player_id' });
     Player.hasMany(SetPosition, { as: 'SetPositions', foreignKey: 'player_id' });
-    Player.hasMany(Spike, { as: 'Spikes', foreignKey: 'player_id' });
-    Player.hasMany(Substitution, { as: 'OutSubstitutions', foreignKey: 'player_out' });
-    Player.hasMany(Substitution, { as: 'InSubstitutions', foreignKey: 'player_id' });
     Player.hasOne(DraftPick, { as: 'DraftPick', foreignKey: 'player_id' });
     Player.hasOne(PerformanceStats, { as: 'PerformanceStat', foreignKey: 'player_id' });
     PlayerTeam.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
@@ -157,27 +126,8 @@ export function initModels(sequelize) {
     PlayerTrait.belongsTo(Trait, { as: 'trait', foreignKey: 'trait_id' });
     Rally.belongsTo(MatchSet, { as: 'matchSet', foreignKey: 'match_set_id' });
     Rally.belongsTo(Team, { as: 'ServingTeam', foreignKey: 'serving_team' });
-    Rally.hasMany(Block, { as: 'Blocks', foreignKey: 'rally_id' });
-    Rally.hasMany(Event, { as: 'Events', foreignKey: 'rally_id' });
-    Rally.hasMany(LiberoReplacement, { as: 'LiberoReplacements', foreignKey: 'rally_id' });
-    Rally.hasMany(Reception, { as: 'Receptions', foreignKey: 'rally_id' });
-    Rally.hasMany(Serve, { as: 'Serves', foreignKey: 'rally_id' });
-    Rally.hasMany(Set, { as: 'Sets', foreignKey: 'rally_id' });
-    Rally.hasMany(Spike, { as: 'Spikes', foreignKey: 'rally_id' });
-    Rally.hasMany(Substitution, { as: 'Substitutions', foreignKey: 'rally_id' });
-    Reception.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
-    Reception.belongsTo(Rally, { as: 'rally', foreignKey: 'rally_id' });
-    Serve.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
-    Serve.belongsTo(Rally, { as: 'rally', foreignKey: 'rally_id' });
-    Set.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
-    Set.belongsTo(Rally, { as: 'rally', foreignKey: 'rally_id' });
     SetPosition.belongsTo(MatchSet, { as: 'matchSet', foreignKey: 'match_set_id' });
     SetPosition.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
-    Spike.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
-    Spike.belongsTo(Rally, { as: 'rally', foreignKey: 'rally_id' });
-    Substitution.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
-    Substitution.belongsTo(Player, { as: 'playerOut', foreignKey: 'player_out' });
-    Substitution.belongsTo(Rally, { as: 'rally', foreignKey: 'rally_id' });
     Team.belongsTo(Coach, { as: 'coach', foreignKey: 'coach_id' });
     Team.belongsTo(Country, { as: 'country', foreignKey: 'country_id' });
     Team.belongsTo(League, { as: 'league', foreignKey: 'league_id' });
@@ -215,7 +165,6 @@ export function initModels(sequelize) {
     });
     Trait.hasMany(PlayerTrait, { as: 'PlayerTraits', foreignKey: 'trait_id' });
     return {
-        Block,
         Coach,
         Competition,
         CompetitionChampion,
@@ -228,7 +177,6 @@ export function initModels(sequelize) {
         Iteration,
         League,
         LeagueSeason,
-        LiberoReplacement,
         Match,
         MatchRating,
         MatchSet,
@@ -238,12 +186,7 @@ export function initModels(sequelize) {
         PlayerTeam,
         PlayerTrait,
         Rally,
-        Reception,
-        Serve,
-        Set,
         SetPosition,
-        Spike,
-        Substitution,
         Team,
         Trait,
         User

package/dist/esm/src/data/models/coach.js

@@ -42,9 +42,9 @@ export class CoachModel extends Model {
                     name: 'Coach_pk',
                     unique: true,
                     fields: [
-                        { name: 'coach_id' },
+                        { name: 'coach_id' }
                     ]
-                },
+                }
             ]
         });
     }

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

@@ -1,4 +1,3 @@
-export * from './block';
 export * from './coach';
 export * from './competition';
 export * from './competition-champion';
@@ -7,11 +6,9 @@ export * from './competition-teams';
 export * from './country';
 export * from './draft';
 export * from './draft-pick';
-export * from './event';
 export * from './iteration';
 export * from './league';
 export * from './league-season';
-export * from './libero-replacement';
 export * from './match';
 export * from './match-rating';
 export * from './match-set';
@@ -21,12 +18,7 @@ export * from './player';
 export * from './player-team';
 export * from './player-trait';
 export * from './rally';
-export * from './reception';
-export * from './serve';
-export * from './set';
 export * from './set-position';
-export * from './spike';
-export * from './substitution';
 export * from './team';
 export * from './trait';
 export * from './user';

package/dist/esm/src/data/models/index.js

@@ -1,4 +1,3 @@
-export * from './block';
 export * from './coach';
 export * from './competition';
 export * from './competition-champion';
@@ -7,11 +6,9 @@ export * from './competition-teams';
 export * from './country';
 export * from './draft';
 export * from './draft-pick';
-export * from './event';
 export * from './iteration';
 export * from './league';
 export * from './league-season';
-export * from './libero-replacement';
 export * from './match';
 export * from './match-rating';
 export * from './match-set';
@@ -21,12 +18,7 @@ export * from './player';
 export * from './player-team';
 export * from './player-trait';
 export * from './rally';
-export * from './reception';
-export * from './serve';
-export * from './set';
 export * from './set-position';
-export * from './spike';
-export * from './substitution';
 export * from './team';
 export * from './trait';
 export * from './user';

package/dist/esm/src/data/models/player-team.d.ts

@@ -1,7 +1,6 @@
 import * as Sequelize from 'sequelize';
 import { Model, Optional } from 'sequelize';
-import { PlayerId, PlayerModel } from '.';
-import { TeamId, TeamModel } from '.';
+import { PlayerId, PlayerModel, TeamId, TeamModel } from '.';
 export interface PlayerTeamAttributes {
     player_id: string;
     team_id: string;