volleyballsimtypes 0.0.100 → 0.0.102

package/dist/cjs/src/service/match/match-set.js

@@ -9,14 +9,14 @@ var ScoreThreshold;
     ScoreThreshold[ScoreThreshold["TIE_BREAK"] = 15] = "TIE_BREAK";
 })(ScoreThreshold || (ScoreThreshold = {}));
 class MatchSet {
-    constructor({ id, order, isTieBreak, homeLibero, awayLibero, stats, rallies, homeScore, awayScore }) {
+    constructor({ id, order, isTieBreak, homePlayerPosition, awayPlayerPosition, stats, rallies, homeScore, awayScore }) {
         (0, utils_1.validateUUID)(id);
         this.id = id;
         this.order = order;
         this.homeScore = homeScore;
         this.awayScore = awayScore;
-        this.homeLibero = homeLibero;
-        this.awayLibero = awayLibero;
+        this.homePlayerPosition = homePlayerPosition;
+        this.awayPlayerPosition = awayPlayerPosition;
         this.stats = stats;
         this.rallies = rallies;
         this.isTieBreak = isTieBreak;

package/dist/cjs/src/service/match/rally.d.ts

@@ -1,13 +1,11 @@
 import { Team } from '../team';
 import { CourtPosition } from './court-position';
-import { RallyEvent, Score } from '../event';
+import { RallyEvent } from '../event';
 interface RallyOpts {
     readonly id: string;
     readonly order: number;
     readonly servingTeam: Team;
     readonly events: RallyEvent[];
-    readonly homePlayerPosition: PlayerPosition[];
-    readonly awayPlayerPosition: PlayerPosition[];
 }
 export interface PlayerPosition {
     position: CourtPosition;
@@ -17,11 +15,8 @@ export declare class Rally {
     readonly id: string;
     readonly servingTeam: Team;
     readonly events: RallyEvent[];
-    readonly homePlayerPosition: PlayerPosition[];
-    readonly awayPlayerPosition: PlayerPosition[];
     readonly order: number;
-    constructor({ id, order, servingTeam, homePlayerPosition, awayPlayerPosition, events }: RallyOpts);
-    get score(): Score | undefined;
+    constructor({ id, order, servingTeam, events }: RallyOpts);
     addEvent(event: RallyEvent): void;
 }
 export {};

package/dist/cjs/src/service/match/rally.js

@@ -2,20 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Rally = void 0;
 const utils_1 = require("../utils");
-const event_1 = require("../event");
 class Rally {
-    constructor({ id, order, servingTeam, homePlayerPosition, awayPlayerPosition, events }) {
+    constructor({ id, order, servingTeam, events }) {
         (0, utils_1.validateUUID)(id);
         this.id = id;
         this.order = order;
         this.servingTeam = servingTeam;
-        this.homePlayerPosition = homePlayerPosition;
-        this.awayPlayerPosition = awayPlayerPosition;
         this.events = events;
     }
-    get score() {
-        return this.events.find(e => e.eventType === event_1.EventTypeEnum.SCORE);
-    }
     addEvent(event) {
         this.events.push(event);
     }

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

@@ -13,8 +13,8 @@ export interface APIMatchSet {
     readonly id: string;
     order: number;
     isTieBreak: boolean;
-    homeLiberoId: string | undefined;
-    awayLiberoId: string | undefined;
+    homePlayerPosition: PlayerPosition[];
+    awayPlayerPosition: PlayerPosition[];
     homeScore: number;
     awayScore: number;
     stats: APISetStatistics[];
@@ -24,8 +24,6 @@ export interface APIRally {
     readonly id: string;
     servingTeamId: string;
     events: APIEvent[];
-    homePlayerPosition: PlayerPosition[];
-    awayPlayerPosition: PlayerPosition[];
     order: number;
 }
 export interface APISetStatistics {

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

@@ -1,14 +1,19 @@
 import type { Sequelize } from 'sequelize';
-import { BlockModel, CoachModel, CountryModel, DraftModel, DraftPickModel, EventModel, IterationModel, LeagueModel, LiberoReplacementModel, MatchModel, MatchRatingModel, MatchSetModel, MatchSetStatsModel, PerformanceStatsModel, PlayerModel, PlayerTeamModel, RallyModel, RallyPositionModel, ReceptionModel, ScoreModel, SeasonMatchModel, SeasonModel, SeasonTeamsModel, ServeModel, SetModel, SpikeModel, SubstitutionModel, TeamModel, TournamentMatchModel, TournamentModel, TournamentTeamsModel, UserModel } from './models';
+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;
@@ -17,20 +22,15 @@ export declare function initModels(sequelize: Sequelize): {
     PerformanceStats: typeof PerformanceStatsModel;
     Player: typeof PlayerModel;
     PlayerTeam: typeof PlayerTeamModel;
+    PlayerTrait: typeof PlayerTraitModel;
     Rally: typeof RallyModel;
-    RallyPosition: typeof RallyPositionModel;
     Reception: typeof ReceptionModel;
-    Score: typeof ScoreModel;
-    Season: typeof SeasonModel;
-    SeasonTeams: typeof SeasonTeamsModel;
-    SeasonMatch: typeof SeasonMatchModel;
     Serve: typeof ServeModel;
     Set: typeof SetModel;
+    SetPosition: typeof SetPositionModel;
     Spike: typeof SpikeModel;
     Substitution: typeof SubstitutionModel;
     Team: typeof TeamModel;
-    Tournament: typeof TournamentModel;
-    TournamentMatch: typeof TournamentMatchModel;
-    TournamentTeams: typeof TournamentTeamsModel;
+    Trait: typeof TraitModel;
     User: typeof UserModel;
 };

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

@@ -1,13 +1,18 @@
-import { BlockModel, CoachModel, CountryModel, DraftModel, DraftPickModel, EventModel, IterationModel, LeagueModel, LiberoReplacementModel, MatchModel, MatchRatingModel, MatchSetModel, MatchSetStatsModel, PerformanceStatsModel, PlayerModel, PlayerTeamModel, PlayerTraitModel, RallyModel, RallyPositionModel, ReceptionModel, ScoreModel, SeasonMatchModel, SeasonModel, SeasonTeamsModel, ServeModel, SetModel, SpikeModel, SubstitutionModel, TeamModel, TournamentMatchModel, TournamentModel, TournamentTeamsModel, TraitModel, UserModel } from './models';
+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 function initModels(sequelize) {
     const Block = BlockModel.initModel(sequelize);
     const Coach = CoachModel.initModel(sequelize);
     const Country = CountryModel.initModel(sequelize);
+    const Competition = CompetitionModel.initModel(sequelize);
+    const CompetitionTeams = CompetitionTeamsModel.initModel(sequelize);
+    const CompetitionChampion = CompetitionChampionModel.initModel(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);
@@ -18,26 +23,15 @@ export function initModels(sequelize) {
     const PlayerTeam = PlayerTeamModel.initModel(sequelize);
     const PlayerTrait = PlayerTraitModel.initModel(sequelize);
     const Rally = RallyModel.initModel(sequelize);
-    const RallyPosition = RallyPositionModel.initModel(sequelize);
+    const SetPosition = SetPositionModel.initModel(sequelize);
     const Reception = ReceptionModel.initModel(sequelize);
-    const Score = ScoreModel.initModel(sequelize);
-    const Season = SeasonModel.initModel(sequelize);
-    const SeasonMatch = SeasonMatchModel.initModel(sequelize);
-    const SeasonTeams = SeasonTeamsModel.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 Tournament = TournamentModel.initModel(sequelize);
-    const TournamentMatch = TournamentMatchModel.initModel(sequelize);
-    const TournamentTeams = TournamentTeamsModel.initModel(sequelize);
     const Trait = TraitModel.initModel(sequelize);
     const User = UserModel.initModel(sequelize);
-    Draft.hasMany(DraftPick, { as: 'DraftPicks', foreignKey: 'draft_id' });
-    DraftPick.belongsTo(Draft, { as: 'draft', foreignKey: 'draft_id' });
-    DraftPick.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
-    DraftPick.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
     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' });
@@ -45,87 +39,92 @@ export function initModels(sequelize) {
     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' });
+    Competition.hasMany(CompetitionMatch, { as: 'CompetitionMatches', foreignKey: 'competition_id' });
+    Competition.hasMany(CompetitionTeams, { as: 'CompetitionTeams', foreignKey: 'competition_id' });
+    Competition.hasOne(CompetitionChampion, { as: 'CompetitionChampion', foreignKey: 'competition_id' });
+    Competition.hasOne(LeagueSeason, { as: 'LeagueSeason', foreignKey: 'competition_id' });
+    Competition.belongsToMany(Team, {
+        as: 'Teams',
+        through: CompetitionTeams,
+        foreignKey: 'competition_id',
+        otherKey: 'team_id'
+    });
+    CompetitionChampion.belongsTo(Competition, { as: 'competition', foreignKey: 'competition_id' });
+    CompetitionChampion.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
+    CompetitionMatch.belongsTo(Competition, { as: 'Competition', foreignKey: 'competition_id' });
+    CompetitionMatch.belongsTo(Match, { as: 'Match', foreignKey: 'match_id' });
+    CompetitionTeams.belongsTo(Competition, { as: 'competition', foreignKey: 'competition_id' });
+    CompetitionTeams.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
     Country.hasMany(Coach, { as: 'Coaches', foreignKey: 'country_id' });
     Country.hasMany(League, { as: 'Leagues', foreignKey: 'country_id' });
     Country.hasMany(Player, { as: 'Players', foreignKey: 'country_id' });
     Country.hasMany(Team, { as: 'Teams', foreignKey: 'country_id' });
+    Draft.hasMany(DraftPick, { as: 'DraftPicks', foreignKey: 'draft_id' });
+    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(Season, { as: 'Seasons', foreignKey: 'iteration' });
-    Iteration.hasOne(Tournament, { as: 'Tournament', foreignKey: 'iteration' });
+    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' });
-    League.hasMany(Season, { as: 'Seasons', 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.hasMany(MatchSet, { as: 'MatchSets', foreignKey: 'match_id' });
-    Match.hasOne(SeasonMatch, { as: 'SeasonMatch', foreignKey: 'match_id' });
-    Match.hasOne(TournamentMatch, { as: 'TournamentMatch', foreignKey: 'match_id' });
-    Match.hasMany(MatchRating, { as: 'MatchRatings', foreignKey: 'match_id' });
+    Match.belongsTo(Team, { as: 'AwayTeam', foreignKey: 'away_team' });
+    Match.belongsTo(Team, { as: 'HomeTeam', foreignKey: 'home_team' });
     Match.belongsToMany(Team, {
-        as: 'team_id_Teams',
+        as: 'TeamMatchRatings',
         through: MatchRating,
         foreignKey: 'match_id',
         otherKey: 'team_id'
     });
+    Match.hasMany(MatchRating, { as: 'MatchRatings', foreignKey: 'match_id' });
+    Match.hasMany(MatchSet, { as: 'MatchSets', foreignKey: 'match_id' });
+    Match.hasOne(CompetitionMatch, { as: 'CompetitionMatch', foreignKey: 'match_id' });
     MatchRating.belongsTo(Match, { as: 'match', foreignKey: 'match_id' });
     MatchRating.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
     MatchSet.belongsTo(Match, { as: 'match', foreignKey: 'match_id' });
-    MatchSet.belongsTo(Player, { as: 'awayLibero', foreignKey: 'away_libero' });
-    MatchSet.belongsTo(Player, { as: 'homeLibero', foreignKey: 'home_libero' });
-    MatchSet.hasMany(MatchSetStats, { as: 'MatchSetStats', foreignKey: 'match_set_id' });
-    MatchSet.hasMany(Rally, { as: 'Rallies', foreignKey: 'match_set_id' });
     MatchSet.belongsToMany(Player, {
-        as: 'players',
+        as: 'SetPositionsPlayer',
+        through: SetPosition,
+        foreignKey: 'match_set_id',
+        otherKey: 'player_id'
+    });
+    MatchSet.belongsToMany(Player, {
+        as: 'SetStatsPlayers',
         through: MatchSetStats,
         foreignKey: 'match_set_id',
         otherKey: 'player_id'
     });
-    MatchSetStats.belongsTo(MatchSet, { as: 'match_set', foreignKey: 'match_set_id' });
+    MatchSet.hasMany(MatchSetStats, { as: 'MatchSetStats', foreignKey: 'match_set_id' });
+    MatchSet.hasMany(Rally, { as: 'Rallies', foreignKey: 'match_set_id' });
+    MatchSet.hasMany(SetPosition, { as: 'SetPositions', foreignKey: 'match_set_id' });
+    MatchSetStats.belongsTo(MatchSet, { as: 'matchSet', foreignKey: 'match_set_id' });
     MatchSetStats.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
     PerformanceStats.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
     Player.belongsTo(Country, { as: 'country', foreignKey: 'country_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(MatchSet, { as: 'awayLiberoMatchSets', foreignKey: 'away_libero' });
-    Player.hasMany(MatchSet, { as: 'homeLiberoMatchSets', foreignKey: 'home_libero' });
-    Player.hasMany(MatchSetStats, { as: 'MatchSetStats', foreignKey: 'player_id' });
-    Player.hasMany(RallyPosition, { as: 'RallyPositions', foreignKey: 'player_id' });
-    Player.hasMany(Reception, { as: 'Receptions', foreignKey: 'player_id' });
-    Player.hasMany(Score, { as: 'Scores', foreignKey: 'player_id' });
-    Player.hasMany(Serve, { as: 'Serves', foreignKey: 'player_id' });
-    Player.hasMany(Set, { as: 'Sets', 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(PerformanceStats, { as: 'PerformanceStat', foreignKey: 'player_id' });
-    Player.hasOne(DraftPick, { as: 'DraftPick', foreignKey: 'player_id' });
-    Player.belongsToMany(Team, {
-        as: 'Teams',
-        through: PlayerTeam,
+    Player.belongsToMany(MatchSet, {
+        as: 'SetPositionSets',
+        through: SetPosition,
         foreignKey: 'player_id',
-        otherKey: 'team_id'
+        otherKey: 'match_set_id'
     });
-    Player.hasMany(PlayerTeam, { as: 'PlayerTeams', foreignKey: 'player_id' });
     Player.belongsToMany(MatchSet, {
-        as: 'matchSets',
+        as: 'StatsMatchSets',
         through: MatchSetStats,
         foreignKey: 'player_id',
         otherKey: 'match_set_id'
     });
-    Player.belongsToMany(Rally, {
-        as: 'rallies',
-        through: RallyPosition,
+    Player.belongsToMany(Team, {
+        as: 'Teams',
+        through: PlayerTeam,
         foreignKey: 'player_id',
-        otherKey: 'rally_id'
+        otherKey: 'team_id'
     });
     Player.belongsToMany(Trait, {
         as: 'Traits',
@@ -133,53 +132,47 @@ 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' });
     PlayerTeam.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
+    PlayerTrait.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
     PlayerTrait.belongsTo(Trait, { as: 'trait', foreignKey: 'trait_id' });
-    Rally.belongsTo(MatchSet, { as: 'match_set', foreignKey: 'match_set_id' });
-    Rally.belongsTo(Team, { as: 'servingTeam', foreignKey: 'serving_team' });
+    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(RallyPosition, { as: 'RallyPositions', foreignKey: 'rally_id' });
     Rally.hasMany(Reception, { as: 'Receptions', foreignKey: 'rally_id' });
-    Rally.hasMany(Score, { as: 'Scores', 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' });
-    Rally.belongsToMany(Player, {
-        as: 'players',
-        through: RallyPosition,
-        foreignKey: 'rally_id',
-        otherKey: 'player_id'
-    });
-    RallyPosition.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
-    RallyPosition.belongsTo(Rally, { as: 'rally', foreignKey: 'rally_id' });
     Reception.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
     Reception.belongsTo(Rally, { as: 'rally', foreignKey: 'rally_id' });
-    Score.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
-    Score.belongsTo(Rally, { as: 'rally', foreignKey: 'rally_id' });
-    Score.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
-    Season.belongsTo(League, { as: 'league', foreignKey: 'league_id' });
-    Season.belongsTo(Iteration, { as: 'Iteration', foreignKey: 'iteration' });
-    Season.belongsTo(Team, { as: 'Champion', foreignKey: 'champion' });
-    Season.hasMany(SeasonMatch, { as: 'SeasonMatches', foreignKey: 'season_id' });
-    Season.hasMany(SeasonTeams, { as: 'SeasonTeams', foreignKey: 'season_id' });
-    Season.belongsToMany(Team, {
-        as: 'seasonTeams',
-        through: SeasonTeams,
-        foreignKey: 'season_id',
-        otherKey: 'team_id'
-    });
-    SeasonMatch.belongsTo(Match, { as: 'match', foreignKey: 'match_id' });
-    SeasonMatch.belongsTo(Season, { as: 'season', foreignKey: 'season_id' });
-    SeasonTeams.belongsTo(Season, { as: 'season', foreignKey: 'season_id' });
-    SeasonTeams.belongsTo(Team, { as: 'team', foreignKey: 'team_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' });
@@ -188,55 +181,32 @@ export function initModels(sequelize) {
     Team.belongsTo(Coach, { as: 'coach', foreignKey: 'coach_id' });
     Team.belongsTo(Country, { as: 'country', foreignKey: 'country_id' });
     Team.belongsTo(League, { as: 'league', foreignKey: 'league_id' });
-    Team.hasMany(Match, { as: 'homeMatches', foreignKey: 'home_team' });
-    Team.hasMany(Match, { as: 'awayMatches', foreignKey: 'away_team' });
-    Team.hasMany(Rally, { as: 'Rallies', foreignKey: 'serving_team' });
-    Team.hasMany(Score, { as: 'Scores', foreignKey: 'team_id' });
-    Team.hasMany(Season, { as: 'seasonTitles', foreignKey: 'champion' });
-    Team.hasMany(Tournament, { as: 'tournamentTitles', foreignKey: 'champion' });
-    Team.hasMany(SeasonTeams, { as: 'SeasonTeams', foreignKey: 'team_id' });
-    Team.hasMany(DraftPick, { as: 'DraftPicks', foreignKey: 'team_id' });
+    Team.belongsToMany(Competition, {
+        as: 'Competitions',
+        through: CompetitionTeams,
+        foreignKey: 'team_id',
+        otherKey: 'competition_id'
+    });
     Team.belongsToMany(Match, {
-        as: 'matches',
+        as: 'RatingMatches',
         through: MatchRating,
         foreignKey: 'team_id',
         otherKey: 'match_id'
     });
-    Team.hasMany(MatchRating, { as: 'MatchRatings', foreignKey: 'team_id' });
     Team.belongsToMany(Player, {
         as: 'Players',
         through: PlayerTeam,
         foreignKey: 'team_id',
         otherKey: 'player_id'
     });
+    Team.hasMany(CompetitionChampion, { as: 'CompetitionChampions', foreignKey: 'team_id' });
+    Team.hasMany(CompetitionTeams, { as: 'CompetitionTeams', foreignKey: 'team_id' });
+    Team.hasMany(DraftPick, { as: 'DraftPicks', foreignKey: 'team_id' });
+    Team.hasMany(Match, { as: 'HomeMatches', foreignKey: 'home_team' });
+    Team.hasMany(Match, { as: 'AwayMatches', foreignKey: 'away_team' });
+    Team.hasMany(MatchRating, { as: 'MatchRatings', foreignKey: 'team_id' });
     Team.hasMany(PlayerTeam, { as: 'PlayerTeams', foreignKey: 'team_id' });
-    Team.belongsToMany(Season, {
-        as: 'seasons',
-        through: SeasonTeams,
-        foreignKey: 'team_id',
-        otherKey: 'season_id'
-    });
-    Team.hasMany(TournamentTeams, { as: 'TournamentTeams', foreignKey: 'team_id' });
-    Team.belongsToMany(Tournament, {
-        as: 'tournaments',
-        through: TournamentTeams,
-        foreignKey: 'team_id',
-        otherKey: 'tournament_id'
-    });
-    Tournament.belongsTo(Team, { as: 'Champion', foreignKey: 'champion' });
-    Tournament.belongsTo(Iteration, { as: 'Iteration', foreignKey: 'iteration' });
-    Tournament.hasMany(TournamentMatch, { as: 'TournamentMatches', foreignKey: 'tournament_id' });
-    Tournament.hasMany(TournamentTeams, { as: 'TournamentTeams', foreignKey: 'tournament_id' });
-    Tournament.belongsToMany(Team, {
-        as: 'tournamentTeams',
-        through: TournamentTeams,
-        foreignKey: 'tournament_id',
-        otherKey: 'team_id'
-    });
-    TournamentMatch.belongsTo(Match, { as: 'match', foreignKey: 'match_id' });
-    TournamentMatch.belongsTo(Tournament, { as: 'tournament', foreignKey: 'tournament_id' });
-    TournamentTeams.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
-    TournamentTeams.belongsTo(Tournament, { as: 'tournament', foreignKey: 'tournament_id' });
+    Team.hasMany(Rally, { as: 'Rallies', foreignKey: 'serving_team' });
     Trait.belongsToMany(Player, {
         as: 'Players',
         through: PlayerTrait,
@@ -247,12 +217,17 @@ export function initModels(sequelize) {
     return {
         Block,
         Coach,
+        Competition,
+        CompetitionChampion,
+        CompetitionMatch,
+        CompetitionTeams,
         Country,
         Draft,
         DraftPick,
         Event,
         Iteration,
         League,
+        LeagueSeason,
         LiberoReplacement,
         Match,
         MatchRating,
@@ -261,21 +236,16 @@ export function initModels(sequelize) {
         PerformanceStats,
         Player,
         PlayerTeam,
+        PlayerTrait,
         Rally,
-        RallyPosition,
         Reception,
-        Score,
-        Season,
-        SeasonTeams,
-        SeasonMatch,
         Serve,
         Set,
+        SetPosition,
         Spike,
         Substitution,
         Team,
-        Tournament,
-        TournamentMatch,
-        TournamentTeams,
+        Trait,
         User
     };
 }

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

@@ -4,34 +4,34 @@ import { CourtTarget, EventType, PlayerId, PlayerModel, RallyId, RallyModel } fr
 export interface BlockAttributes {
     event_id: string;
     rally_id: string;
-    event_type: EventType;
+    order: number;
+    player_id: string;
     target: CourtTarget;
     type: BlockType;
     failure: BlockFailure;
-    order: number;
-    player_id: string;
     blocker_1?: string;
     blocker_2?: string;
     blocker_3?: string;
+    event_type: EventType;
 }
+export type BlockPk = 'event_id';
 export type BlockType = 'NO_BLOCKER' | 'SINGLE' | 'DOUBLE' | 'TRIPLE';
 export type BlockFailure = 'NO_FAILURE' | 'FAULT' | 'MISS' | 'OUT_OF_BOUNDS' | 'WIPE' | 'TOOL';
-export type BlockPk = 'event_id';
 export type BlockId = BlockModel[BlockPk];
 export type BlockOptionalAttributes = 'blocker_1' | 'blocker_2' | 'blocker_3';
 export type BlockCreationAttributes = Optional<BlockAttributes, BlockOptionalAttributes>;
 export declare class BlockModel extends Model<BlockAttributes, BlockCreationAttributes> implements BlockAttributes {
     event_id: string;
     rally_id: string;
-    event_type: EventType;
+    order: number;
+    player_id: string;
     target: CourtTarget;
     type: BlockType;
     failure: BlockFailure;
-    order: number;
-    player_id: string;
     blocker_1?: string;
     blocker_2?: string;
     blocker_3?: string;
+    event_type: EventType;
     player: PlayerModel;
     getPlayer: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
     setPlayer: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;

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

@@ -15,22 +15,6 @@ export class BlockModel extends Model {
                     key: 'rally_id'
                 }
             },
-            event_type: {
-                type: DataTypes.ENUM('LIBERO_REPLACEMENT', 'SUBSTITUTION', 'SERVE', 'RECEPTION', 'SET', 'SPIKE', 'BLOCK', 'SCORE'),
-                allowNull: false
-            },
-            target: {
-                type: DataTypes.ENUM('NO_TARGET', 'OPPONENT_RIGHT_BACK', 'OPPONENT_MIDDLE_BACK', 'OPPONENT_LEFT_BACK', 'OPPONENT_RIGHT_FRONT', 'OPPONENT_MIDDLE_FRONT', 'OPPONENT_LEFT_FRONT', 'TEAM_LEFT_FRONT', 'TEAM_MIDDLE_FRONT', 'TEAM_RIGHT_FRONT', 'TEAM_LEFT_BACK', 'TEAM_MIDDLE_BACK', 'TEAM_RIGHT_BACK'),
-                allowNull: false
-            },
-            type: {
-                type: DataTypes.ENUM('NO_BLOCKER', 'SINGLE', 'DOUBLE', 'TRIPLE'),
-                allowNull: false
-            },
-            failure: {
-                type: DataTypes.ENUM('NO_FAILURE', 'FAULT', 'MISS', 'OUT_OF_BOUNDS', 'WIPE', 'TOOL'),
-                allowNull: false
-            },
             order: {
                 type: DataTypes.INTEGER,
                 allowNull: false
@@ -43,6 +27,18 @@ export class BlockModel extends Model {
                     key: 'player_id'
                 }
             },
+            target: {
+                type: DataTypes.ENUM('NO_TARGET', 'OPPONENT_LEFT_BACK', 'OPPONENT_LEFT_FRONT', 'OPPONENT_MIDDLE_BACK', 'OPPONENT_MIDDLE_FRONT', 'OPPONENT_RIGHT_BACK', 'OPPONENT_RIGHT_FRONT', 'TEAM_LEFT_BACK', 'TEAM_LEFT_FRONT', 'TEAM_MIDDLE_BACK', 'TEAM_MIDDLE_FRONT', 'TEAM_RIGHT_BACK', 'TEAM_RIGHT_FRONT'),
+                allowNull: false
+            },
+            type: {
+                type: DataTypes.ENUM('DOUBLE', 'NO_BLOCKER', 'SINGLE', 'TRIPLE'),
+                allowNull: false
+            },
+            failure: {
+                type: DataTypes.ENUM('FAULT', 'MISS', 'NO_FAILURE', 'OUT_OF_BOUNDS', 'TOOL', 'WIPE'),
+                allowNull: false
+            },
             blocker_1: {
                 type: DataTypes.UUID,
                 allowNull: true,
@@ -66,6 +62,10 @@ export class BlockModel extends Model {
                     model: 'Player',
                     key: 'player_id'
                 }
+            },
+            event_type: {
+                type: DataTypes.ENUM('BLOCK', 'LIBERO_REPLACEMENT', 'RECEPTION', 'SERVE', 'SET', 'SPIKE', 'SUBSTITUTION'),
+                allowNull: false
             }
         }, {
             sequelize,

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

@@ -1,6 +1,6 @@
 import * as Sequelize from 'sequelize';
 import { Model, Optional } from 'sequelize';
-import type { CountryId, CountryModel, TeamId, TeamModel } from '.';
+import { CountryId, CountryModel, TeamId, TeamModel } from '.';
 export interface CoachAttributes {
     coach_id: string;
     formation: FormationType;
@@ -9,9 +9,9 @@ export interface CoachAttributes {
     last_name: string;
     country_id: string;
 }
+export type FormationType = '4-2' | '5-1' | '6-2';
 export type CoachPk = 'coach_id';
 export type CoachId = CoachModel[CoachPk];
-export type FormationType = '4-2' | '6-2' | '5-1';
 export type CoachOptionalAttributes = 'substitution_tolerance';
 export type CoachCreationAttributes = Optional<CoachAttributes, CoachOptionalAttributes>;
 export declare class CoachModel extends Model<CoachAttributes, CoachCreationAttributes> implements CoachAttributes {

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

@@ -8,7 +8,7 @@ export class CoachModel extends Model {
                 primaryKey: true
             },
             formation: {
-                type: DataTypes.ENUM('4-2', '6-2', '5-1'),
+                type: DataTypes.ENUM('4-2', '5-1', '6-2'),
                 allowNull: false
             },
             substitution_tolerance: {
@@ -42,9 +42,9 @@ export class CoachModel extends Model {
                     name: 'Coach_pk',
                     unique: true,
                     fields: [
-                        { name: 'coach_id' }
+                        { name: 'coach_id' },
                     ]
-                }
+                },
             ]
         });
     }