volleyballsimtypes 0.0.100 → 0.0.102

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

@@ -4,12 +4,12 @@ import { CourtTarget, EventType, PlayerId, PlayerModel, RallyId, RallyModel } fr
 export interface SetAttributes {
     event_id: string;
     rally_id: string;
+    order: number;
+    player_id: string;
     event_type: EventType;
     failure: SetFailure;
     type: SetType;
     target: CourtTarget;
-    order: number;
-    player_id: string;
 }
 export type SetFailure = 'NO_FAILURE' | 'FAULT' | 'MISS' | 'OUT_OF_BOUNDS' | 'BAD_PASS';
 export type SetType = 'OVERHAND' | 'UNDERHAND' | 'SPIKE' | 'DUMP';
@@ -19,12 +19,12 @@ export type SetCreationAttributes = SetAttributes;
 export declare class SetModel extends Model<SetAttributes, SetCreationAttributes> implements SetAttributes {
     event_id: string;
     rally_id: string;
+    order: number;
+    player_id: string;
     event_type: EventType;
     failure: SetFailure;
     type: SetType;
     target: CourtTarget;
-    order: number;
-    player_id: string;
     player: PlayerModel;
     getPlayer: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
     setPlayer: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;

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

@@ -15,33 +15,33 @@ export class SetModel extends Model {
                     key: 'rally_id'
                 }
             },
-            event_type: {
-                type: DataTypes.ENUM('LIBERO_REPLACEMENT', 'SUBSTITUTION', 'SERVE', 'RECEPTION', 'SET', 'SPIKE', 'BLOCK', 'SCORE'),
+            order: {
+                type: DataTypes.INTEGER,
                 allowNull: false
             },
+            player_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'Player',
+                    key: 'player_id'
+                }
+            },
             failure: {
-                type: DataTypes.ENUM('NO_FAILURE', 'FAULT', 'MISS', 'OUT_OF_BOUNDS', 'BAD_PASS'),
+                type: DataTypes.ENUM('BAD_PASS', 'FAULT', 'MISS', 'NO_FAILURE', 'OUT_OF_BOUNDS'),
                 allowNull: false
             },
             type: {
-                type: DataTypes.ENUM('OVERHAND', 'UNDERHAND', 'SPIKE', 'DUMP'),
+                type: DataTypes.ENUM('DUMP', 'OVERHAND', 'SPIKE', 'UNDERHAND'),
                 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'),
+                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
             },
-            order: {
-                type: DataTypes.INTEGER,
+            event_type: {
+                type: DataTypes.ENUM('BLOCK', 'LIBERO_REPLACEMENT', 'RECEPTION', 'SERVE', 'SET', 'SPIKE', 'SUBSTITUTION'),
                 allowNull: false
-            },
-            player_id: {
-                type: DataTypes.UUID,
-                allowNull: false,
-                references: {
-                    model: 'Player',
-                    key: 'player_id'
-                }
             }
         }, {
             sequelize,

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

@@ -4,12 +4,12 @@ import { CourtTarget, EventType, PlayerId, PlayerModel, RallyId, RallyModel } fr
 export interface SpikeAttributes {
     event_id: string;
     rally_id: string;
+    order: number;
+    player_id: string;
     event_type: EventType;
     target: CourtTarget;
     type: SpikeType;
     failure: SpikeFailure;
-    order: number;
-    player_id: string;
 }
 export type SpikeType = 'CROSS_SHOT' | 'LINE_SHOT' | 'TOOL_SHOT' | 'TIP' | 'DOWN_BALL' | 'OVERHAND';
 export type SpikeFailure = 'NO_FAILURE' | 'FAULT' | 'MISS' | 'OUT_OF_BOUNDS' | 'NET';
@@ -19,12 +19,12 @@ export type SpikeCreationAttributes = SpikeAttributes;
 export declare class SpikeModel extends Model<SpikeAttributes, SpikeCreationAttributes> implements SpikeAttributes {
     event_id: string;
     rally_id: string;
+    order: number;
+    player_id: string;
     event_type: EventType;
     target: CourtTarget;
     type: SpikeType;
     failure: SpikeFailure;
-    order: number;
-    player_id: string;
     player: PlayerModel;
     getPlayer: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
     setPlayer: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;

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

@@ -15,33 +15,33 @@ export class SpikeModel extends Model {
                     key: 'rally_id'
                 }
             },
-            event_type: {
-                type: DataTypes.ENUM('LIBERO_REPLACEMENT', 'SUBSTITUTION', 'SERVE', 'RECEPTION', 'SET', 'SPIKE', 'BLOCK', 'SCORE'),
+            order: {
+                type: DataTypes.INTEGER,
                 allowNull: false
             },
+            player_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'Player',
+                    key: 'player_id'
+                }
+            },
             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'),
+                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('CROSS_SHOT', 'LINE_SHOT', 'TOOL_SHOT', 'TIP', 'DOWN_BALL', 'OVERHAND'),
+                type: DataTypes.ENUM('CROSS_SHOT', 'DOWN_BALL', 'LINE_SHOT', 'OVERHAND', 'TIP', 'TOOL_SHOT'),
                 allowNull: false
             },
             failure: {
-                type: DataTypes.ENUM('NO_FAILURE', 'FAULT', 'MISS', 'OUT_OF_BOUNDS', 'NET'),
+                type: DataTypes.ENUM('FAULT', 'MISS', 'NET', 'NO_FAILURE', 'OUT_OF_BOUNDS'),
                 allowNull: false
             },
-            order: {
-                type: DataTypes.INTEGER,
+            event_type: {
+                type: DataTypes.ENUM('BLOCK', 'LIBERO_REPLACEMENT', 'RECEPTION', 'SERVE', 'SET', 'SPIKE', 'SUBSTITUTION'),
                 allowNull: false
-            },
-            player_id: {
-                type: DataTypes.UUID,
-                allowNull: false,
-                references: {
-                    model: 'Player',
-                    key: 'player_id'
-                }
             }
         }, {
             sequelize,

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

@@ -1,13 +1,13 @@
 import * as Sequelize from 'sequelize';
 import { Model } from 'sequelize';
-import type { EventType, PlayerId, PlayerModel, RallyId, RallyModel } from '.';
+import { EventType, PlayerId, PlayerModel, RallyId, RallyModel } from '.';
 export interface SubstitutionAttributes {
     event_id: string;
     rally_id: string;
-    event_type: EventType;
-    player_out: string;
     order: number;
     player_id: string;
+    player_out: string;
+    event_type: EventType;
 }
 export type SubstitutionPk = 'event_id';
 export type SubstitutionId = SubstitutionModel[SubstitutionPk];
@@ -15,10 +15,10 @@ export type SubstitutionCreationAttributes = SubstitutionAttributes;
 export declare class SubstitutionModel extends Model<SubstitutionAttributes, SubstitutionCreationAttributes> implements SubstitutionAttributes {
     event_id: string;
     rally_id: string;
-    event_type: EventType;
-    player_out: string;
     order: number;
     player_id: string;
+    player_out: string;
+    event_type: EventType;
     playerOut: PlayerModel;
     getPlayerOut: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
     setPlayerOut: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;

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

@@ -15,11 +15,11 @@ export class SubstitutionModel extends Model {
                     key: 'rally_id'
                 }
             },
-            event_type: {
-                type: DataTypes.ENUM('LIBERO_REPLACEMENT', 'SUBSTITUTION', 'SERVE', 'RECEPTION', 'SET', 'SPIKE', 'BLOCK', 'SCORE'),
+            order: {
+                type: DataTypes.INTEGER,
                 allowNull: false
             },
-            player_out: {
+            player_id: {
                 type: DataTypes.UUID,
                 allowNull: false,
                 references: {
@@ -27,32 +27,28 @@ export class SubstitutionModel extends Model {
                     key: 'player_id'
                 }
             },
-            order: {
-                type: DataTypes.INTEGER,
-                allowNull: false
-            },
-            player_id: {
+            player_out: {
                 type: DataTypes.UUID,
                 allowNull: false,
                 references: {
                     model: 'Player',
                     key: 'player_id'
                 }
+            },
+            event_type: {
+                type: DataTypes.ENUM('BLOCK', 'LIBERO_REPLACEMENT', 'RECEPTION', 'SERVE', 'SET', 'SPIKE', 'SUBSTITUTION'),
+                allowNull: false
             }
         }, {
             sequelize,
             tableName: 'Substitution',
             schema: 'public',
             timestamps: false,
-            indexes: [
-                {
+            indexes: [{
                     name: 'Substitution_pk',
                     unique: true,
-                    fields: [
-                        { name: 'event_id' }
-                    ]
-                }
-            ]
+                    fields: [{ name: 'event_id' }]
+                }]
         });
     }
 }

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

@@ -1,7 +1,6 @@
 import * as Sequelize from 'sequelize';
-import { Model } from 'sequelize';
-import { CoachAttributes, CoachModel, CountryModel, DraftPickModel, LeagueAttributes, LeagueModel, MatchModel, MatchRatingModel, PlayerAttributes, PlayerId, PlayerModel, PlayerTeamModel, RallyModel, ScoreModel, SeasonModel, SeasonTeamsModel, TournamentModel, TournamentTeamsModel } from '.';
-import type { CoachId, CountryId, DraftPickId, LeagueId, MatchId, MatchRatingId, PlayerTeamId, RallyId, ScoreId, SeasonId, SeasonTeamsId, TournamentId, TournamentTeamsId } from './';
+import { Model, Optional } from 'sequelize';
+import { CoachAttributes, CoachId, CoachModel, CompetitionChampionId, CompetitionChampionModel, CompetitionId, CompetitionModel, CompetitionTeamsId, CompetitionTeamsModel, CountryId, CountryModel, DraftPickId, DraftPickModel, LeagueAttributes, LeagueId, LeagueModel, MatchId, MatchModel, MatchRatingId, MatchRatingModel, PlayerAttributes, PlayerId, PlayerModel, PlayerTeamId, PlayerTeamModel, RallyId, RallyModel } from '.';
 export interface TeamAttributes {
     team_id: string;
     name: string;
@@ -16,17 +15,17 @@ export interface TeamAttributes {
 }
 export type TeamPk = 'team_id';
 export type TeamId = TeamModel[TeamPk];
-export type TeamCreationAttributes = TeamAttributes;
+export type TeamOptionalAttributes = 'rating';
+export type TeamCreationAttributes = Optional<TeamAttributes, TeamOptionalAttributes>;
 export declare class TeamModel extends Model<TeamAttributes, TeamCreationAttributes> implements TeamAttributes {
     team_id: string;
+    coach_id: string;
     name: string;
     short_name: string;
-    rating: number;
-    coach_id: string;
-    league_id: string;
     country_id: string;
+    league_id: string;
+    rating: number;
     coach: CoachModel;
-    league: LeagueModel;
     getCoach: Sequelize.BelongsToGetAssociationMixin<CoachModel>;
     setCoach: Sequelize.BelongsToSetAssociationMixin<CoachModel, CoachId>;
     createCoach: Sequelize.BelongsToCreateAssociationMixin<CoachModel>;
@@ -34,9 +33,43 @@ export declare class TeamModel extends Model<TeamAttributes, TeamCreationAttribu
     getCountry: Sequelize.BelongsToGetAssociationMixin<CountryModel>;
     setCountry: Sequelize.BelongsToSetAssociationMixin<CountryModel, CountryId>;
     createCountry: Sequelize.BelongsToCreateAssociationMixin<CountryModel>;
+    league: LeagueModel;
     getLeague: Sequelize.BelongsToGetAssociationMixin<LeagueModel>;
     setLeague: Sequelize.BelongsToSetAssociationMixin<LeagueModel, LeagueId>;
     createLeague: Sequelize.BelongsToCreateAssociationMixin<LeagueModel>;
+    Competitions: CompetitionModel[];
+    getCompetitions: Sequelize.BelongsToManyGetAssociationsMixin<CompetitionModel>;
+    setCompetitions: Sequelize.BelongsToManySetAssociationsMixin<CompetitionModel, CompetitionId>;
+    addCompetition: Sequelize.BelongsToManyAddAssociationMixin<CompetitionModel, CompetitionId>;
+    addCompetitions: Sequelize.BelongsToManyAddAssociationsMixin<CompetitionModel, CompetitionId>;
+    createCompetition: Sequelize.BelongsToManyCreateAssociationMixin<CompetitionModel>;
+    removeCompetition: Sequelize.BelongsToManyRemoveAssociationMixin<CompetitionModel, CompetitionId>;
+    removeCompetitions: Sequelize.BelongsToManyRemoveAssociationsMixin<CompetitionModel, CompetitionId>;
+    hasCompetition: Sequelize.BelongsToManyHasAssociationMixin<CompetitionModel, CompetitionId>;
+    hasCompetitions: Sequelize.BelongsToManyHasAssociationsMixin<CompetitionModel, CompetitionId>;
+    countCompetitions: Sequelize.BelongsToManyCountAssociationsMixin;
+    CompetitionChampions: CompetitionChampionModel[];
+    getCompetitionChampions: Sequelize.HasManyGetAssociationsMixin<CompetitionChampionModel>;
+    setCompetitionChampions: Sequelize.HasManySetAssociationsMixin<CompetitionChampionModel, CompetitionChampionId>;
+    addCompetitionChampion: Sequelize.HasManyAddAssociationMixin<CompetitionChampionModel, CompetitionChampionId>;
+    addCompetitionChampions: Sequelize.HasManyAddAssociationsMixin<CompetitionChampionModel, CompetitionChampionId>;
+    createCompetitionChampion: Sequelize.HasManyCreateAssociationMixin<CompetitionChampionModel>;
+    removeCompetitionChampion: Sequelize.HasManyRemoveAssociationMixin<CompetitionChampionModel, CompetitionChampionId>;
+    removeCompetitionChampions: Sequelize.HasManyRemoveAssociationsMixin<CompetitionChampionModel, CompetitionChampionId>;
+    hasCompetitionChampion: Sequelize.HasManyHasAssociationMixin<CompetitionChampionModel, CompetitionChampionId>;
+    hasCompetitionChampions: Sequelize.HasManyHasAssociationsMixin<CompetitionChampionModel, CompetitionChampionId>;
+    countCompetitionChampions: Sequelize.HasManyCountAssociationsMixin;
+    CompetitionTeams: CompetitionTeamsModel[];
+    getCompetitionTeams: Sequelize.HasManyGetAssociationsMixin<CompetitionTeamsModel>;
+    setCompetitionTeams: Sequelize.HasManySetAssociationsMixin<CompetitionTeamsModel, CompetitionTeamsId>;
+    addCompetitionTeam: Sequelize.HasManyAddAssociationMixin<CompetitionTeamsModel, CompetitionTeamsId>;
+    addCompetitionTeams: Sequelize.HasManyAddAssociationsMixin<CompetitionTeamsModel, CompetitionTeamsId>;
+    createCompetitionTeam: Sequelize.HasManyCreateAssociationMixin<CompetitionTeamsModel>;
+    removeCompetitionTeam: Sequelize.HasManyRemoveAssociationMixin<CompetitionTeamsModel, CompetitionTeamsId>;
+    removeCompetitionTeams: Sequelize.HasManyRemoveAssociationsMixin<CompetitionTeamsModel, CompetitionTeamsId>;
+    hasCompetitionTeam: Sequelize.HasManyHasAssociationMixin<CompetitionTeamsModel, CompetitionTeamsId>;
+    hasCompetitionTeams: Sequelize.HasManyHasAssociationsMixin<CompetitionTeamsModel, CompetitionTeamsId>;
+    countCompetitionTeams: Sequelize.HasManyCountAssociationsMixin;
     DraftPicks: DraftPickModel[];
     getDraftPicks: Sequelize.HasManyGetAssociationsMixin<DraftPickModel>;
     setDraftPicks: Sequelize.HasManySetAssociationsMixin<DraftPickModel, DraftPickId>;
@@ -48,7 +81,7 @@ export declare class TeamModel extends Model<TeamAttributes, TeamCreationAttribu
     hasDraftPick: Sequelize.HasManyHasAssociationMixin<DraftPickModel, DraftPickId>;
     hasDraftPicks: Sequelize.HasManyHasAssociationsMixin<DraftPickModel, DraftPickId>;
     countDraftPicks: Sequelize.HasManyCountAssociationsMixin;
-    homeMatches: MatchModel[];
+    HomeMatches: MatchModel[];
     getHomeMatches: Sequelize.HasManyGetAssociationsMixin<MatchModel>;
     setHomeMatches: Sequelize.HasManySetAssociationsMixin<MatchModel, MatchId>;
     addHomeMatch: Sequelize.HasManyAddAssociationMixin<MatchModel, MatchId>;
@@ -59,7 +92,7 @@ export declare class TeamModel extends Model<TeamAttributes, TeamCreationAttribu
     hasHomeMatch: Sequelize.HasManyHasAssociationMixin<MatchModel, MatchId>;
     hasHomeMatches: Sequelize.HasManyHasAssociationsMixin<MatchModel, MatchId>;
     countHomeMatches: Sequelize.HasManyCountAssociationsMixin;
-    awayMatches: MatchModel[];
+    AwayMatches: MatchModel[];
     getAwayMatches: Sequelize.HasManyGetAssociationsMixin<MatchModel>;
     setAwayMatches: Sequelize.HasManySetAssociationsMixin<MatchModel, MatchId>;
     addAwayMatch: Sequelize.HasManyAddAssociationMixin<MatchModel, MatchId>;
@@ -70,17 +103,17 @@ export declare class TeamModel extends Model<TeamAttributes, TeamCreationAttribu
     hasAwayMatch: Sequelize.HasManyHasAssociationMixin<MatchModel, MatchId>;
     hasAwayMatches: Sequelize.HasManyHasAssociationsMixin<MatchModel, MatchId>;
     countAwayMatches: Sequelize.HasManyCountAssociationsMixin;
-    matches: MatchModel[];
-    getMatches: Sequelize.BelongsToManyGetAssociationsMixin<MatchModel>;
-    setMatches: Sequelize.BelongsToManySetAssociationsMixin<MatchModel, MatchId>;
-    addMatch: Sequelize.BelongsToManyAddAssociationMixin<MatchModel, MatchId>;
-    addMatches: Sequelize.BelongsToManyAddAssociationsMixin<MatchModel, MatchId>;
-    createMatch: Sequelize.BelongsToManyCreateAssociationMixin<MatchModel>;
-    removeMatch: Sequelize.BelongsToManyRemoveAssociationMixin<MatchModel, MatchId>;
-    removeMatches: Sequelize.BelongsToManyRemoveAssociationsMixin<MatchModel, MatchId>;
-    hasMatch: Sequelize.BelongsToManyHasAssociationMixin<MatchModel, MatchId>;
-    hasMatches: Sequelize.BelongsToManyHasAssociationsMixin<MatchModel, MatchId>;
-    countMatches: Sequelize.BelongsToManyCountAssociationsMixin;
+    RatingMatches: MatchModel[];
+    getRatingMatches: Sequelize.BelongsToManyGetAssociationsMixin<MatchModel>;
+    setRatingMatches: Sequelize.BelongsToManySetAssociationsMixin<MatchModel, MatchId>;
+    addRatingMatch: Sequelize.BelongsToManyAddAssociationMixin<MatchModel, MatchId>;
+    addRatingMatches: Sequelize.BelongsToManyAddAssociationsMixin<MatchModel, MatchId>;
+    createRatingMatch: Sequelize.BelongsToManyCreateAssociationMixin<MatchModel>;
+    removeRatingMatch: Sequelize.BelongsToManyRemoveAssociationMixin<MatchModel, MatchId>;
+    removeRatingMatches: Sequelize.BelongsToManyRemoveAssociationsMixin<MatchModel, MatchId>;
+    hasRatingMatch: Sequelize.BelongsToManyHasAssociationMixin<MatchModel, MatchId>;
+    hasRatingMatches: Sequelize.BelongsToManyHasAssociationsMixin<MatchModel, MatchId>;
+    countRatingMatches: Sequelize.BelongsToManyCountAssociationsMixin;
     MatchRatings: MatchRatingModel[];
     getMatchRatings: Sequelize.HasManyGetAssociationsMixin<MatchRatingModel>;
     setMatchRatings: Sequelize.HasManySetAssociationsMixin<MatchRatingModel, MatchRatingId>;
@@ -92,6 +125,17 @@ export declare class TeamModel extends Model<TeamAttributes, TeamCreationAttribu
     hasMatchRating: Sequelize.HasManyHasAssociationMixin<MatchRatingModel, MatchRatingId>;
     hasMatchRatings: Sequelize.HasManyHasAssociationsMixin<MatchRatingModel, MatchRatingId>;
     countMatchRatings: Sequelize.HasManyCountAssociationsMixin;
+    Players: PlayerModel[];
+    getPlayers: Sequelize.BelongsToManyGetAssociationsMixin<PlayerModel>;
+    setPlayers: Sequelize.BelongsToManySetAssociationsMixin<PlayerModel, PlayerId>;
+    addPlayer: Sequelize.BelongsToManyAddAssociationMixin<PlayerModel, PlayerId>;
+    addPlayers: Sequelize.BelongsToManyAddAssociationsMixin<PlayerModel, PlayerId>;
+    createPlayer: Sequelize.BelongsToManyCreateAssociationMixin<PlayerModel>;
+    removePlayer: Sequelize.BelongsToManyRemoveAssociationMixin<PlayerModel, PlayerId>;
+    removePlayers: Sequelize.BelongsToManyRemoveAssociationsMixin<PlayerModel, PlayerId>;
+    hasPlayer: Sequelize.BelongsToManyHasAssociationMixin<PlayerModel, PlayerId>;
+    hasPlayers: Sequelize.BelongsToManyHasAssociationsMixin<PlayerModel, PlayerId>;
+    countPlayers: Sequelize.BelongsToManyCountAssociationsMixin;
     PlayerTeams: PlayerTeamModel[];
     getPlayerTeams: Sequelize.HasManyGetAssociationsMixin<PlayerTeamModel>;
     setPlayerTeams: Sequelize.HasManySetAssociationsMixin<PlayerTeamModel, PlayerTeamId>;
@@ -114,93 +158,5 @@ export declare class TeamModel extends Model<TeamAttributes, TeamCreationAttribu
     hasRally: Sequelize.HasManyHasAssociationMixin<RallyModel, RallyId>;
     hasRallies: Sequelize.HasManyHasAssociationsMixin<RallyModel, RallyId>;
     countRallies: Sequelize.HasManyCountAssociationsMixin;
-    Scores: ScoreModel[];
-    getScores: Sequelize.HasManyGetAssociationsMixin<ScoreModel>;
-    setScores: Sequelize.HasManySetAssociationsMixin<ScoreModel, ScoreId>;
-    addScore: Sequelize.HasManyAddAssociationMixin<ScoreModel, ScoreId>;
-    addScores: Sequelize.HasManyAddAssociationsMixin<ScoreModel, ScoreId>;
-    createScore: Sequelize.HasManyCreateAssociationMixin<ScoreModel>;
-    removeScore: Sequelize.HasManyRemoveAssociationMixin<ScoreModel, ScoreId>;
-    removeScores: Sequelize.HasManyRemoveAssociationsMixin<ScoreModel, ScoreId>;
-    hasScore: Sequelize.HasManyHasAssociationMixin<ScoreModel, ScoreId>;
-    hasScores: Sequelize.HasManyHasAssociationsMixin<ScoreModel, ScoreId>;
-    countScores: Sequelize.HasManyCountAssociationsMixin;
-    seasonTitles: SeasonModel[];
-    getSeasonTitles: Sequelize.HasManyGetAssociationsMixin<SeasonModel>;
-    setSeasonTitles: Sequelize.HasManySetAssociationsMixin<SeasonModel, SeasonId>;
-    addSeasonTitle: Sequelize.HasManyAddAssociationMixin<SeasonModel, SeasonId>;
-    addSeasonTitles: Sequelize.HasManyAddAssociationsMixin<SeasonModel, SeasonId>;
-    createSeasonTitle: Sequelize.HasManyCreateAssociationMixin<SeasonModel>;
-    removeSeasonTitle: Sequelize.HasManyRemoveAssociationMixin<SeasonModel, SeasonId>;
-    removeSeasonTitles: Sequelize.HasManyRemoveAssociationsMixin<SeasonModel, SeasonId>;
-    hasSeasonTitle: Sequelize.HasManyHasAssociationMixin<SeasonModel, SeasonId>;
-    hasSeasonTitles: Sequelize.HasManyHasAssociationsMixin<SeasonModel, SeasonId>;
-    countSeasonTitles: Sequelize.HasManyCountAssociationsMixin;
-    seasons: SeasonModel[];
-    getSeasons: Sequelize.BelongsToManyGetAssociationsMixin<SeasonModel>;
-    setSeasons: Sequelize.BelongsToManySetAssociationsMixin<SeasonModel, SeasonId>;
-    addSeason: Sequelize.BelongsToManyAddAssociationMixin<SeasonModel, SeasonId>;
-    addSeasons: Sequelize.BelongsToManyAddAssociationsMixin<SeasonModel, SeasonId>;
-    createSeason: Sequelize.BelongsToManyCreateAssociationMixin<SeasonModel>;
-    removeSeason: Sequelize.BelongsToManyRemoveAssociationMixin<SeasonModel, SeasonId>;
-    removeSeasons: Sequelize.BelongsToManyRemoveAssociationsMixin<SeasonModel, SeasonId>;
-    hasSeason: Sequelize.BelongsToManyHasAssociationMixin<SeasonModel, SeasonId>;
-    hasSeasons: Sequelize.BelongsToManyHasAssociationsMixin<SeasonModel, SeasonId>;
-    countSeasons: Sequelize.BelongsToManyCountAssociationsMixin;
-    SeasonTeams: SeasonTeamsModel[];
-    getSeasonTeams: Sequelize.HasManyGetAssociationsMixin<SeasonTeamsModel>;
-    setSeasonTeams: Sequelize.HasManySetAssociationsMixin<SeasonTeamsModel, SeasonTeamsId>;
-    addSeasonTeam: Sequelize.HasManyAddAssociationMixin<SeasonTeamsModel, SeasonTeamsId>;
-    addSeasonTeams: Sequelize.HasManyAddAssociationsMixin<SeasonTeamsModel, SeasonTeamsId>;
-    createSeasonTeam: Sequelize.HasManyCreateAssociationMixin<SeasonTeamsModel>;
-    removeSeasonTeam: Sequelize.HasManyRemoveAssociationMixin<SeasonTeamsModel, SeasonTeamsId>;
-    removeSeasonTeams: Sequelize.HasManyRemoveAssociationsMixin<SeasonTeamsModel, SeasonTeamsId>;
-    hasSeasonTeam: Sequelize.HasManyHasAssociationMixin<SeasonTeamsModel, SeasonTeamsId>;
-    hasSeasonTeams: Sequelize.HasManyHasAssociationsMixin<SeasonTeamsModel, SeasonTeamsId>;
-    countSeasonTeams: Sequelize.HasManyCountAssociationsMixin;
-    tournamentTitles: TournamentModel[];
-    getTournamentTitles: Sequelize.HasManyGetAssociationsMixin<TournamentModel>;
-    setTournamentTitles: Sequelize.HasManySetAssociationsMixin<TournamentModel, TournamentId>;
-    addTournamentTitle: Sequelize.HasManyAddAssociationMixin<TournamentModel, TournamentId>;
-    addTournamentTitles: Sequelize.HasManyAddAssociationsMixin<TournamentModel, TournamentId>;
-    createTournamentTitle: Sequelize.HasManyCreateAssociationMixin<TournamentModel>;
-    removeTournamentTitle: Sequelize.HasManyRemoveAssociationMixin<TournamentModel, TournamentId>;
-    removeTournamentTitles: Sequelize.HasManyRemoveAssociationsMixin<TournamentModel, TournamentId>;
-    hasTournamentTitle: Sequelize.HasManyHasAssociationMixin<TournamentModel, TournamentId>;
-    hasTournamentTitles: Sequelize.HasManyHasAssociationsMixin<TournamentModel, TournamentId>;
-    countTournamentTitles: Sequelize.HasManyCountAssociationsMixin;
-    tournaments: TournamentModel[];
-    getTournaments: Sequelize.BelongsToManyGetAssociationsMixin<TournamentModel>;
-    setTournaments: Sequelize.BelongsToManySetAssociationsMixin<TournamentModel, TournamentId>;
-    addTournament: Sequelize.BelongsToManyAddAssociationMixin<TournamentModel, TournamentId>;
-    addTournaments: Sequelize.BelongsToManyAddAssociationsMixin<TournamentModel, TournamentId>;
-    createTournament: Sequelize.BelongsToManyCreateAssociationMixin<TournamentModel>;
-    removeTournament: Sequelize.BelongsToManyRemoveAssociationMixin<TournamentModel, TournamentId>;
-    removeTournaments: Sequelize.BelongsToManyRemoveAssociationsMixin<TournamentModel, TournamentId>;
-    hasTournament: Sequelize.BelongsToManyHasAssociationMixin<TournamentModel, TournamentId>;
-    hasTournaments: Sequelize.BelongsToManyHasAssociationsMixin<TournamentModel, TournamentId>;
-    countTournaments: Sequelize.BelongsToManyCountAssociationsMixin;
-    TournamentTeams: TournamentTeamsModel[];
-    getTournamentTeams: Sequelize.HasManyGetAssociationsMixin<TournamentTeamsModel>;
-    setTournamentTeams: Sequelize.HasManySetAssociationsMixin<TournamentTeamsModel, TournamentTeamsId>;
-    addTournamentTeam: Sequelize.HasManyAddAssociationMixin<TournamentTeamsModel, TournamentTeamsId>;
-    addTournamentTeams: Sequelize.HasManyAddAssociationsMixin<TournamentTeamsModel, TournamentTeamsId>;
-    createTournamentTeam: Sequelize.HasManyCreateAssociationMixin<TournamentTeamsModel>;
-    removeTournamentTeam: Sequelize.HasManyRemoveAssociationMixin<TournamentTeamsModel, TournamentTeamsId>;
-    removeTournamentTeams: Sequelize.HasManyRemoveAssociationsMixin<TournamentTeamsModel, TournamentTeamsId>;
-    hasTournamentTeam: Sequelize.HasManyHasAssociationMixin<TournamentTeamsModel, TournamentTeamsId>;
-    hasTournamentTeams: Sequelize.HasManyHasAssociationsMixin<TournamentTeamsModel, TournamentTeamsId>;
-    countTournamentTeams: Sequelize.HasManyCountAssociationsMixin;
-    Players: PlayerModel[];
-    getPlayers: Sequelize.BelongsToManyGetAssociationsMixin<PlayerModel>;
-    setPlayers: Sequelize.BelongsToManySetAssociationsMixin<PlayerModel, PlayerId>;
-    addPlayer: Sequelize.BelongsToManyAddAssociationMixin<PlayerModel, PlayerId>;
-    addPlayers: Sequelize.BelongsToManyAddAssociationsMixin<PlayerModel, PlayerId>;
-    createPlayer: Sequelize.BelongsToManyCreateAssociationMixin<PlayerModel>;
-    removePlayer: Sequelize.BelongsToManyRemoveAssociationMixin<PlayerModel, PlayerId>;
-    removePlayers: Sequelize.BelongsToManyRemoveAssociationsMixin<PlayerModel, PlayerId>;
-    hasPlayer: Sequelize.BelongsToManyHasAssociationMixin<PlayerModel, PlayerId>;
-    hasPlayers: Sequelize.BelongsToManyHasAssociationsMixin<PlayerModel, PlayerId>;
-    countPlayers: Sequelize.BelongsToManyCountAssociationsMixin;
     static initModel(sequelize: Sequelize.Sequelize): typeof TeamModel;
 }

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

@@ -15,28 +15,13 @@ export class TeamModel extends Model {
                     key: 'coach_id'
                 }
             },
-            league_id: {
-                type: DataTypes.UUID,
-                allowNull: false,
-                references: {
-                    model: 'League',
-                    key: 'league_id'
-                }
-            },
             name: {
-                type: DataTypes.STRING(50),
-                allowNull: false,
-                unique: true
+                type: DataTypes.STRING,
+                allowNull: false
             },
             short_name: {
                 type: DataTypes.STRING,
-                allowNull: false,
-                unique: true
-            },
-            rating: {
-                type: DataTypes.FLOAT,
-                allowNull: false,
-                unique: true
+                allowNull: false
             },
             country_id: {
                 type: DataTypes.UUID,
@@ -45,6 +30,19 @@ export class TeamModel extends Model {
                     model: 'Country',
                     key: 'country_id'
                 }
+            },
+            league_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'League',
+                    key: 'league_id'
+                }
+            },
+            rating: {
+                type: DataTypes.REAL,
+                allowNull: false,
+                defaultValue: 1000.0
             }
         }, {
             sequelize,

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

@@ -9,8 +9,8 @@ export interface UserAttributes {
 }
 export type UserPk = 'user_id';
 export type UserId = UserModel[UserPk];
-export type UserOptionalAttributes = 'role';
 export type UserRole = 'ADMIN' | 'PLAYER';
+export type UserOptionalAttributes = 'role';
 export type UserCreationAttributes = Optional<UserAttributes, UserOptionalAttributes>;
 export declare class UserModel extends Model<UserAttributes, UserCreationAttributes> implements UserAttributes {
     user_id: string;

package/dist/esm/src/data/transformers/court-position.d.ts

@@ -1,5 +1,5 @@
 import { CourtPosition } from '../../service';
-type position = 'NOT_IN_COURT' | 'LIBERO_ZONE' | 'LEFT_FRONT' | 'MIDDLE_FRONT' | 'RIGHT_FRONT' | 'LEFT_BACK' | 'MIDDLE_BACK' | 'RIGHT_BACK';
-declare function transformToType(position: CourtPosition): position;
-declare function transformFromType(position: position): CourtPosition;
+import { CourtPositionType } from '../models';
+declare function transformToType(position: CourtPosition): CourtPositionType;
+declare function transformFromType(position: CourtPositionType): CourtPosition;
 export { transformToType as transformFromCourtPosition, transformFromType as transformToCourtPosition };

package/dist/esm/src/data/transformers/event-type.js

@@ -13,8 +13,6 @@ function transformToType(type) {
             return 'RECEPTION';
         case EventTypeEnum.SET:
             return 'SET';
-        case EventTypeEnum.SCORE:
-            return 'SCORE';
         case EventTypeEnum.LIBERO_REPLACEMENT:
             return 'LIBERO_REPLACEMENT';
         default:

package/dist/esm/src/data/transformers/formation.d.ts

@@ -1,5 +1,5 @@
 import { Formation } from '../../service';
-import { FormationType as TeamFormation } from '../models';
-declare function transformToType(_formation: Formation): TeamFormation;
-declare function transformFromType(_formation: TeamFormation): Formation;
+import { FormationType } from '../models';
+declare function transformToType(_formation: Formation): FormationType;
+declare function transformFromType(_formation: FormationType): Formation;
 export { transformToType as transformFromFormation, transformFromType as transformToFormation };

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

@@ -19,10 +19,9 @@ export * from './match-set-stats';
 export * from './performance-stats';
 export * from './player';
 export * from './rally';
-export * from './rally-position';
+export * from './set-position';
 export * from './reception';
 export * from './role';
-export * from './score';
 export * from './season';
 export * from './season-match';
 export * from './player-team';

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

@@ -19,10 +19,9 @@ export * from './match-set-stats';
 export * from './performance-stats';
 export * from './player';
 export * from './rally';
-export * from './rally-position';
+export * from './set-position';
 export * from './reception';
 export * from './role';
-export * from './score';
 export * from './season';
 export * from './season-match';
 export * from './player-team';

package/dist/esm/src/data/transformers/league.js

@@ -8,11 +8,12 @@ function transformToAttributes(league) {
     };
 }
 function transformToObject(model) {
+    const seasons = model.LeagueSeasons != null ? model.LeagueSeasons.map(ls => transformToSeason(ls.competition)) : [];
     return new League({
         id: model.league_id,
         name: model.name,
         country: transformToCountry(model.country),
-        seasons: model.Seasons != null ? model.Seasons.map(transformToSeason) : []
+        seasons
     });
 }
 function transformToAPIObject(model) {