volleyballsimtypes 0.0.61 → 0.0.62

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

@@ -1,127 +1,196 @@
-import * as Sequelize from 'sequelize';
-import { Model } from 'sequelize';
-import type { CoachAttributes, CoachId, CoachModel, CountryId, CountryModel, MatchId, MatchModel, PlayerId, PlayerModel, RallyId, RallyModel, ScoreId, ScoreModel, SeasonId, SeasonModel, SeasonTeamsId, SeasonTeamsModel } from '.';
-import { LeagueAttributes, LeagueId, LeagueModel } from '.';
-export interface TeamAttributes {
-    team_id: string;
-    name: string;
-    short_name: string;
-    coach_id?: string;
-    league_id?: string;
-    country_id?: string;
-    coach?: CoachAttributes;
-    league?: LeagueAttributes;
-    Players?: PlayerModel[];
-}
-export type TeamPk = 'team_id';
-export type TeamId = TeamModel[TeamPk];
-export type TeamCreationAttributes = TeamAttributes;
-export declare class TeamModel extends Model<TeamAttributes, TeamCreationAttributes> implements TeamAttributes {
-    team_id: string;
-    name: string;
-    short_name: string;
-    coach_id: string;
-    league_id: string;
-    country_id: string;
-    coach: CoachModel;
-    league: LeagueModel;
-    Players: PlayerModel[];
-    getCoach: Sequelize.BelongsToGetAssociationMixin<CoachModel>;
-    setCoach: Sequelize.BelongsToSetAssociationMixin<CoachModel, CoachId>;
-    createCoach: Sequelize.BelongsToCreateAssociationMixin<CoachModel>;
-    country: CountryModel;
-    getCountry: Sequelize.BelongsToGetAssociationMixin<CountryModel>;
-    setCountry: Sequelize.BelongsToSetAssociationMixin<CountryModel, CountryId>;
-    createCountry: Sequelize.BelongsToCreateAssociationMixin<CountryModel>;
-    getLeague: Sequelize.BelongsToGetAssociationMixin<LeagueModel>;
-    setLeague: Sequelize.BelongsToSetAssociationMixin<LeagueModel, LeagueId>;
-    createLeague: Sequelize.BelongsToCreateAssociationMixin<LeagueModel>;
-    Matches: MatchModel[];
-    getMatches: Sequelize.HasManyGetAssociationsMixin<MatchModel>;
-    setMatches: Sequelize.HasManySetAssociationsMixin<MatchModel, MatchId>;
-    addMatch: Sequelize.HasManyAddAssociationMixin<MatchModel, MatchId>;
-    addMatches: Sequelize.HasManyAddAssociationsMixin<MatchModel, MatchId>;
-    createMatch: Sequelize.HasManyCreateAssociationMixin<MatchModel>;
-    removeMatch: Sequelize.HasManyRemoveAssociationMixin<MatchModel, MatchId>;
-    removeMatches: Sequelize.HasManyRemoveAssociationsMixin<MatchModel, MatchId>;
-    hasMatch: Sequelize.HasManyHasAssociationMixin<MatchModel, MatchId>;
-    hasMatches: Sequelize.HasManyHasAssociationsMixin<MatchModel, MatchId>;
-    countMatches: Sequelize.HasManyCountAssociationsMixin;
-    away_team_Matches: MatchModel[];
-    getAway_team_Matches: Sequelize.HasManyGetAssociationsMixin<MatchModel>;
-    setAway_team_Matches: Sequelize.HasManySetAssociationsMixin<MatchModel, MatchId>;
-    addAway_team_Match: Sequelize.HasManyAddAssociationMixin<MatchModel, MatchId>;
-    addAway_team_Matches: Sequelize.HasManyAddAssociationsMixin<MatchModel, MatchId>;
-    createAway_team_Match: Sequelize.HasManyCreateAssociationMixin<MatchModel>;
-    removeAway_team_Match: Sequelize.HasManyRemoveAssociationMixin<MatchModel, MatchId>;
-    removeAway_team_Matches: Sequelize.HasManyRemoveAssociationsMixin<MatchModel, MatchId>;
-    hasAway_team_Match: Sequelize.HasManyHasAssociationMixin<MatchModel, MatchId>;
-    hasAway_team_Matches: Sequelize.HasManyHasAssociationsMixin<MatchModel, MatchId>;
-    countAway_team_Matches: Sequelize.HasManyCountAssociationsMixin;
-    getPlayers: Sequelize.HasManyGetAssociationsMixin<PlayerModel>;
-    setPlayers: Sequelize.HasManySetAssociationsMixin<PlayerModel, PlayerId>;
-    addPlayer: Sequelize.HasManyAddAssociationMixin<PlayerModel, PlayerId>;
-    addPlayers: Sequelize.HasManyAddAssociationsMixin<PlayerModel, PlayerId>;
-    createPlayer: Sequelize.HasManyCreateAssociationMixin<PlayerModel>;
-    removePlayer: Sequelize.HasManyRemoveAssociationMixin<PlayerModel, PlayerId>;
-    removePlayers: Sequelize.HasManyRemoveAssociationsMixin<PlayerModel, PlayerId>;
-    hasPlayer: Sequelize.HasManyHasAssociationMixin<PlayerModel, PlayerId>;
-    hasPlayers: Sequelize.HasManyHasAssociationsMixin<PlayerModel, PlayerId>;
-    countPlayers: Sequelize.HasManyCountAssociationsMixin;
-    Rallies: RallyModel[];
-    getRallies: Sequelize.HasManyGetAssociationsMixin<RallyModel>;
-    setRallies: Sequelize.HasManySetAssociationsMixin<RallyModel, RallyId>;
-    addRally: Sequelize.HasManyAddAssociationMixin<RallyModel, RallyId>;
-    addRallies: Sequelize.HasManyAddAssociationsMixin<RallyModel, RallyId>;
-    createRally: Sequelize.HasManyCreateAssociationMixin<RallyModel>;
-    removeRally: Sequelize.HasManyRemoveAssociationMixin<RallyModel, RallyId>;
-    removeRallies: Sequelize.HasManyRemoveAssociationsMixin<RallyModel, RallyId>;
-    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;
-    season_id_Seasons: SeasonModel[];
-    getSeason_id_Seasons: Sequelize.BelongsToManyGetAssociationsMixin<SeasonModel>;
-    setSeason_id_Seasons: Sequelize.BelongsToManySetAssociationsMixin<SeasonModel, SeasonId>;
-    addSeason_id_Season: Sequelize.BelongsToManyAddAssociationMixin<SeasonModel, SeasonId>;
-    addSeason_id_Seasons: Sequelize.BelongsToManyAddAssociationsMixin<SeasonModel, SeasonId>;
-    createSeason_id_Season: Sequelize.BelongsToManyCreateAssociationMixin<SeasonModel>;
-    removeSeason_id_Season: Sequelize.BelongsToManyRemoveAssociationMixin<SeasonModel, SeasonId>;
-    removeSeason_id_Seasons: Sequelize.BelongsToManyRemoveAssociationsMixin<SeasonModel, SeasonId>;
-    hasSeason_id_Season: Sequelize.BelongsToManyHasAssociationMixin<SeasonModel, SeasonId>;
-    hasSeason_id_Seasons: Sequelize.BelongsToManyHasAssociationsMixin<SeasonModel, SeasonId>;
-    countSeason_id_Seasons: Sequelize.BelongsToManyCountAssociationsMixin;
-    Season: 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;
-    titles: SeasonModel[];
-    getTitles: Sequelize.HasManyGetAssociationsMixin<SeasonModel>;
-    setTitles: Sequelize.HasManySetAssociationsMixin<SeasonModel, SeasonId>;
-    addTitle: Sequelize.HasManyAddAssociationMixin<SeasonModel, SeasonId>;
-    addTitles: Sequelize.HasManyAddAssociationsMixin<SeasonModel, SeasonId>;
-    createTitle: Sequelize.HasManyCreateAssociationMixin<SeasonModel>;
-    removeTitle: Sequelize.HasManyRemoveAssociationMixin<SeasonModel, SeasonId>;
-    removeTitles: Sequelize.HasManyRemoveAssociationsMixin<SeasonModel, SeasonId>;
-    hasTitle: Sequelize.HasManyHasAssociationMixin<SeasonModel, SeasonId>;
-    hasTitles: Sequelize.HasManyHasAssociationsMixin<SeasonModel, SeasonId>;
-    countTitles: Sequelize.HasManyCountAssociationsMixin;
-    static initModel(sequelize: Sequelize.Sequelize): typeof TeamModel;
-}
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { CoachAttributes, CoachModel, CountryModel, DraftPickModel, LeagueAttributes, LeagueModel, MatchModel, MatchRatingModel, 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 './';
+export interface TeamAttributes {
+    team_id: string;
+    name: string;
+    short_name: string;
+    rating: number;
+    coach_id?: string;
+    league_id?: string;
+    country_id?: string;
+    coach?: CoachAttributes;
+    league?: LeagueAttributes;
+    Players?: PlayerModel[];
+}
+export type TeamPk = 'team_id';
+export type TeamId = TeamModel[TeamPk];
+export type TeamCreationAttributes = TeamAttributes;
+export declare class TeamModel extends Model<TeamAttributes, TeamCreationAttributes> implements TeamAttributes {
+    team_id: string;
+    name: string;
+    short_name: string;
+    rating: number;
+    coach_id: string;
+    league_id: string;
+    country_id: string;
+    coach: CoachModel;
+    Players: PlayerModel[];
+    getCoach: Sequelize.BelongsToGetAssociationMixin<CoachModel>;
+    setCoach: Sequelize.BelongsToSetAssociationMixin<CoachModel, CoachId>;
+    createCoach: Sequelize.BelongsToCreateAssociationMixin<CoachModel>;
+    country: CountryModel;
+    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>;
+    DraftPicks: DraftPickModel[];
+    getDraftPicks: Sequelize.HasManyGetAssociationsMixin<DraftPickModel>;
+    setDraftPicks: Sequelize.HasManySetAssociationsMixin<DraftPickModel, DraftPickId>;
+    addDraftPick: Sequelize.HasManyAddAssociationMixin<DraftPickModel, DraftPickId>;
+    addDraftPicks: Sequelize.HasManyAddAssociationsMixin<DraftPickModel, DraftPickId>;
+    createDraftPick: Sequelize.HasManyCreateAssociationMixin<DraftPickModel>;
+    removeDraftPick: Sequelize.HasManyRemoveAssociationMixin<DraftPickModel, DraftPickId>;
+    removeDraftPicks: Sequelize.HasManyRemoveAssociationsMixin<DraftPickModel, DraftPickId>;
+    hasDraftPick: Sequelize.HasManyHasAssociationMixin<DraftPickModel, DraftPickId>;
+    hasDraftPicks: Sequelize.HasManyHasAssociationsMixin<DraftPickModel, DraftPickId>;
+    countDraftPicks: Sequelize.HasManyCountAssociationsMixin;
+    Matches: MatchModel[];
+    getMatches: Sequelize.HasManyGetAssociationsMixin<MatchModel>;
+    setMatches: Sequelize.HasManySetAssociationsMixin<MatchModel, MatchId>;
+    addMatch: Sequelize.HasManyAddAssociationMixin<MatchModel, MatchId>;
+    addMatches: Sequelize.HasManyAddAssociationsMixin<MatchModel, MatchId>;
+    createMatch: Sequelize.HasManyCreateAssociationMixin<MatchModel>;
+    removeMatch: Sequelize.HasManyRemoveAssociationMixin<MatchModel, MatchId>;
+    removeMatches: Sequelize.HasManyRemoveAssociationsMixin<MatchModel, MatchId>;
+    hasMatch: Sequelize.HasManyHasAssociationMixin<MatchModel, MatchId>;
+    hasMatches: Sequelize.HasManyHasAssociationsMixin<MatchModel, MatchId>;
+    countMatches: Sequelize.HasManyCountAssociationsMixin;
+    away_team_Matches: MatchModel[];
+    getAway_team_Matches: Sequelize.HasManyGetAssociationsMixin<MatchModel>;
+    setAway_team_Matches: Sequelize.HasManySetAssociationsMixin<MatchModel, MatchId>;
+    addAway_team_Match: Sequelize.HasManyAddAssociationMixin<MatchModel, MatchId>;
+    addAway_team_Matches: Sequelize.HasManyAddAssociationsMixin<MatchModel, MatchId>;
+    createAway_team_Match: Sequelize.HasManyCreateAssociationMixin<MatchModel>;
+    removeAway_team_Match: Sequelize.HasManyRemoveAssociationMixin<MatchModel, MatchId>;
+    removeAway_team_Matches: Sequelize.HasManyRemoveAssociationsMixin<MatchModel, MatchId>;
+    hasAway_team_Match: Sequelize.HasManyHasAssociationMixin<MatchModel, MatchId>;
+    hasAway_team_Matches: Sequelize.HasManyHasAssociationsMixin<MatchModel, MatchId>;
+    countAway_team_Matches: Sequelize.HasManyCountAssociationsMixin;
+    match_id_Matches: MatchModel[];
+    getMatch_id_Matches: Sequelize.BelongsToManyGetAssociationsMixin<MatchModel>;
+    setMatch_id_Matches: Sequelize.BelongsToManySetAssociationsMixin<MatchModel, MatchId>;
+    addMatch_id_Match: Sequelize.BelongsToManyAddAssociationMixin<MatchModel, MatchId>;
+    addMatch_id_Matches: Sequelize.BelongsToManyAddAssociationsMixin<MatchModel, MatchId>;
+    createMatch_id_Match: Sequelize.BelongsToManyCreateAssociationMixin<MatchModel>;
+    removeMatch_id_Match: Sequelize.BelongsToManyRemoveAssociationMixin<MatchModel, MatchId>;
+    removeMatch_id_Matches: Sequelize.BelongsToManyRemoveAssociationsMixin<MatchModel, MatchId>;
+    hasMatch_id_Match: Sequelize.BelongsToManyHasAssociationMixin<MatchModel, MatchId>;
+    hasMatch_id_Matches: Sequelize.BelongsToManyHasAssociationsMixin<MatchModel, MatchId>;
+    countMatch_id_Matches: Sequelize.BelongsToManyCountAssociationsMixin;
+    MatchRatings: MatchRatingModel[];
+    getMatchRatings: Sequelize.HasManyGetAssociationsMixin<MatchRatingModel>;
+    setMatchRatings: Sequelize.HasManySetAssociationsMixin<MatchRatingModel, MatchRatingId>;
+    addMatchRating: Sequelize.HasManyAddAssociationMixin<MatchRatingModel, MatchRatingId>;
+    addMatchRatings: Sequelize.HasManyAddAssociationsMixin<MatchRatingModel, MatchRatingId>;
+    createMatchRating: Sequelize.HasManyCreateAssociationMixin<MatchRatingModel>;
+    removeMatchRating: Sequelize.HasManyRemoveAssociationMixin<MatchRatingModel, MatchRatingId>;
+    removeMatchRatings: Sequelize.HasManyRemoveAssociationsMixin<MatchRatingModel, MatchRatingId>;
+    hasMatchRating: Sequelize.HasManyHasAssociationMixin<MatchRatingModel, MatchRatingId>;
+    hasMatchRatings: Sequelize.HasManyHasAssociationsMixin<MatchRatingModel, MatchRatingId>;
+    countMatchRatings: Sequelize.HasManyCountAssociationsMixin;
+    PlayerTeams: PlayerTeamModel[];
+    getPlayerTeams: Sequelize.HasManyGetAssociationsMixin<PlayerTeamModel>;
+    setPlayerTeams: Sequelize.HasManySetAssociationsMixin<PlayerTeamModel, PlayerTeamId>;
+    addPlayerTeam: Sequelize.HasManyAddAssociationMixin<PlayerTeamModel, PlayerTeamId>;
+    addPlayerTeams: Sequelize.HasManyAddAssociationsMixin<PlayerTeamModel, PlayerTeamId>;
+    createPlayerTeam: Sequelize.HasManyCreateAssociationMixin<PlayerTeamModel>;
+    removePlayerTeam: Sequelize.HasManyRemoveAssociationMixin<PlayerTeamModel, PlayerTeamId>;
+    removePlayerTeams: Sequelize.HasManyRemoveAssociationsMixin<PlayerTeamModel, PlayerTeamId>;
+    hasPlayerTeam: Sequelize.HasManyHasAssociationMixin<PlayerTeamModel, PlayerTeamId>;
+    hasPlayerTeams: Sequelize.HasManyHasAssociationsMixin<PlayerTeamModel, PlayerTeamId>;
+    countPlayerTeams: Sequelize.HasManyCountAssociationsMixin;
+    Rallies: RallyModel[];
+    getRallies: Sequelize.HasManyGetAssociationsMixin<RallyModel>;
+    setRallies: Sequelize.HasManySetAssociationsMixin<RallyModel, RallyId>;
+    addRally: Sequelize.HasManyAddAssociationMixin<RallyModel, RallyId>;
+    addRallies: Sequelize.HasManyAddAssociationsMixin<RallyModel, RallyId>;
+    createRally: Sequelize.HasManyCreateAssociationMixin<RallyModel>;
+    removeRally: Sequelize.HasManyRemoveAssociationMixin<RallyModel, RallyId>;
+    removeRallies: Sequelize.HasManyRemoveAssociationsMixin<RallyModel, RallyId>;
+    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;
+    Seasons: SeasonModel[];
+    getSeasons: Sequelize.HasManyGetAssociationsMixin<SeasonModel>;
+    setSeasons: Sequelize.HasManySetAssociationsMixin<SeasonModel, SeasonId>;
+    addSeason: Sequelize.HasManyAddAssociationMixin<SeasonModel, SeasonId>;
+    addSeasons: Sequelize.HasManyAddAssociationsMixin<SeasonModel, SeasonId>;
+    createSeason: Sequelize.HasManyCreateAssociationMixin<SeasonModel>;
+    removeSeason: Sequelize.HasManyRemoveAssociationMixin<SeasonModel, SeasonId>;
+    removeSeasons: Sequelize.HasManyRemoveAssociationsMixin<SeasonModel, SeasonId>;
+    hasSeason: Sequelize.HasManyHasAssociationMixin<SeasonModel, SeasonId>;
+    hasSeasons: Sequelize.HasManyHasAssociationsMixin<SeasonModel, SeasonId>;
+    countSeasons: Sequelize.HasManyCountAssociationsMixin;
+    season_id_Seasons: SeasonModel[];
+    getSeason_id_Seasons: Sequelize.BelongsToManyGetAssociationsMixin<SeasonModel>;
+    setSeason_id_Seasons: Sequelize.BelongsToManySetAssociationsMixin<SeasonModel, SeasonId>;
+    addSeason_id_Season: Sequelize.BelongsToManyAddAssociationMixin<SeasonModel, SeasonId>;
+    addSeason_id_Seasons: Sequelize.BelongsToManyAddAssociationsMixin<SeasonModel, SeasonId>;
+    createSeason_id_Season: Sequelize.BelongsToManyCreateAssociationMixin<SeasonModel>;
+    removeSeason_id_Season: Sequelize.BelongsToManyRemoveAssociationMixin<SeasonModel, SeasonId>;
+    removeSeason_id_Seasons: Sequelize.BelongsToManyRemoveAssociationsMixin<SeasonModel, SeasonId>;
+    hasSeason_id_Season: Sequelize.BelongsToManyHasAssociationMixin<SeasonModel, SeasonId>;
+    hasSeason_id_Seasons: Sequelize.BelongsToManyHasAssociationsMixin<SeasonModel, SeasonId>;
+    countSeason_id_Seasons: 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;
+    Tournaments: TournamentModel[];
+    getTournaments: Sequelize.HasManyGetAssociationsMixin<TournamentModel>;
+    setTournaments: Sequelize.HasManySetAssociationsMixin<TournamentModel, TournamentId>;
+    addTournament: Sequelize.HasManyAddAssociationMixin<TournamentModel, TournamentId>;
+    addTournaments: Sequelize.HasManyAddAssociationsMixin<TournamentModel, TournamentId>;
+    createTournament: Sequelize.HasManyCreateAssociationMixin<TournamentModel>;
+    removeTournament: Sequelize.HasManyRemoveAssociationMixin<TournamentModel, TournamentId>;
+    removeTournaments: Sequelize.HasManyRemoveAssociationsMixin<TournamentModel, TournamentId>;
+    hasTournament: Sequelize.HasManyHasAssociationMixin<TournamentModel, TournamentId>;
+    hasTournaments: Sequelize.HasManyHasAssociationsMixin<TournamentModel, TournamentId>;
+    countTournaments: Sequelize.HasManyCountAssociationsMixin;
+    tournament_id_Tournaments: TournamentModel[];
+    getTournament_id_Tournaments: Sequelize.BelongsToManyGetAssociationsMixin<TournamentModel>;
+    setTournament_id_Tournaments: Sequelize.BelongsToManySetAssociationsMixin<TournamentModel, TournamentId>;
+    addTournament_id_Tournament: Sequelize.BelongsToManyAddAssociationMixin<TournamentModel, TournamentId>;
+    addTournament_id_Tournaments: Sequelize.BelongsToManyAddAssociationsMixin<TournamentModel, TournamentId>;
+    createTournament_id_Tournament: Sequelize.BelongsToManyCreateAssociationMixin<TournamentModel>;
+    removeTournament_id_Tournament: Sequelize.BelongsToManyRemoveAssociationMixin<TournamentModel, TournamentId>;
+    removeTournament_id_Tournaments: Sequelize.BelongsToManyRemoveAssociationsMixin<TournamentModel, TournamentId>;
+    hasTournament_id_Tournament: Sequelize.BelongsToManyHasAssociationMixin<TournamentModel, TournamentId>;
+    hasTournament_id_Tournaments: Sequelize.BelongsToManyHasAssociationsMixin<TournamentModel, TournamentId>;
+    countTournament_id_Tournaments: 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;
+    static initModel(sequelize: Sequelize.Sequelize): typeof TeamModel;
+}

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

@@ -1,64 +1,65 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TeamModel = void 0;
-const sequelize_1 = require("sequelize");
-class TeamModel extends sequelize_1.Model {
-    static initModel(sequelize) {
-        return TeamModel.init({
-            team_id: {
-                type: sequelize_1.DataTypes.UUID,
-                allowNull: false,
-                primaryKey: true
-            },
-            coach_id: {
-                type: sequelize_1.DataTypes.UUID,
-                allowNull: false,
-                references: {
-                    model: 'Coach',
-                    key: 'coach_id'
-                }
-            },
-            league_id: {
-                type: sequelize_1.DataTypes.UUID,
-                allowNull: false,
-                references: {
-                    model: 'League',
-                    key: 'league_id'
-                }
-            },
-            name: {
-                type: sequelize_1.DataTypes.STRING(50),
-                allowNull: false,
-                unique: true
-            },
-            short_name: {
-                type: sequelize_1.DataTypes.STRING,
-                allowNull: false,
-                unique: true
-            },
-            country_id: {
-                type: sequelize_1.DataTypes.UUID,
-                allowNull: false,
-                references: {
-                    model: 'Country',
-                    key: 'country_id'
-                }
-            }
-        }, {
-            sequelize,
-            tableName: 'Team',
-            schema: 'public',
-            timestamps: false,
-            indexes: [
-                {
-                    name: 'Team_pk',
-                    unique: true,
-                    fields: [
-                        { name: 'team_id' }
-                    ]
-                }
-            ]
-        });
-    }
-}
-exports.TeamModel = TeamModel;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TeamModel = void 0;
+const sequelize_1 = require("sequelize");
+class TeamModel extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return TeamModel.init({
+            team_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true
+            },
+            coach_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'Coach',
+                    key: 'coach_id'
+                }
+            },
+            league_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'League',
+                    key: 'league_id'
+                }
+            },
+            name: {
+                type: sequelize_1.DataTypes.STRING(50),
+                allowNull: false,
+                unique: true
+            },
+            short_name: {
+                type: sequelize_1.DataTypes.STRING,
+                allowNull: false,
+                unique: true
+            },
+            rating: {
+                type: sequelize_1.DataTypes.FLOAT,
+                allowNull: false,
+                unique: true
+            },
+            country_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'Country',
+                    key: 'country_id'
+                }
+            }
+        }, {
+            sequelize,
+            tableName: 'Team',
+            schema: 'public',
+            timestamps: false,
+            indexes: [{
+                    name: 'Team_pk',
+                    unique: true,
+                    fields: [{ name: 'team_id' }]
+                }]
+        });
+    }
+}
+exports.TeamModel = TeamModel;

package/dist/cjs/src/data/models/tournament-match.d.ts

@@ -1,29 +1,29 @@
-import * as Sequelize from 'sequelize';
-import { Model } from 'sequelize';
-import type { MatchAttributes, MatchId, MatchModel, TournamentId, TournamentModel } from '.';
-export interface TournamentMatchAttributes {
-    tournament_id: string;
-    match_id: string;
-    index: number;
-    stage: TournamentStage;
-    match?: MatchAttributes;
-}
-export type TournamentStage = 'ROUND_OF_8' | 'QUARTERFINALS' | 'SEMIFINALS' | 'FINAL';
-export type TournamentMatchPk = 'match_id';
-export type TournamentMatchId = TournamentMatchModel[TournamentMatchPk];
-export type TournamentMatchCreationAttributes = TournamentMatchAttributes;
-export declare class TournamentMatchModel extends Model<TournamentMatchAttributes, TournamentMatchCreationAttributes> implements TournamentMatchAttributes {
-    tournament_id: string;
-    match_id: string;
-    index: number;
-    stage: TournamentStage;
-    match: MatchModel;
-    getMatch: Sequelize.BelongsToGetAssociationMixin<MatchModel>;
-    setMatch: Sequelize.BelongsToSetAssociationMixin<MatchModel, MatchId>;
-    createMatch: Sequelize.BelongsToCreateAssociationMixin<MatchModel>;
-    tournament: TournamentModel;
-    getTournament: Sequelize.BelongsToGetAssociationMixin<TournamentModel>;
-    setTournament: Sequelize.BelongsToSetAssociationMixin<TournamentModel, TournamentId>;
-    createTournament: Sequelize.BelongsToCreateAssociationMixin<TournamentModel>;
-    static initModel(sequelize: Sequelize.Sequelize): typeof TournamentMatchModel;
-}
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import type { MatchAttributes, MatchId, MatchModel, TournamentId, TournamentModel } from '.';
+export interface TournamentMatchAttributes {
+    tournament_id: string;
+    match_id: string;
+    index: number;
+    stage: TournamentStage;
+    match?: MatchAttributes;
+}
+export type TournamentStage = 'ROUND_OF_8' | 'QUARTERFINALS' | 'SEMIFINALS' | 'FINAL';
+export type TournamentMatchPk = 'match_id';
+export type TournamentMatchId = TournamentMatchModel[TournamentMatchPk];
+export type TournamentMatchCreationAttributes = TournamentMatchAttributes;
+export declare class TournamentMatchModel extends Model<TournamentMatchAttributes, TournamentMatchCreationAttributes> implements TournamentMatchAttributes {
+    tournament_id: string;
+    match_id: string;
+    index: number;
+    stage: TournamentStage;
+    match: MatchModel;
+    getMatch: Sequelize.BelongsToGetAssociationMixin<MatchModel>;
+    setMatch: Sequelize.BelongsToSetAssociationMixin<MatchModel, MatchId>;
+    createMatch: Sequelize.BelongsToCreateAssociationMixin<MatchModel>;
+    tournament: TournamentModel;
+    getTournament: Sequelize.BelongsToGetAssociationMixin<TournamentModel>;
+    setTournament: Sequelize.BelongsToSetAssociationMixin<TournamentModel, TournamentId>;
+    createTournament: Sequelize.BelongsToCreateAssociationMixin<TournamentModel>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof TournamentMatchModel;
+}

package/dist/cjs/src/data/models/tournament-match.js

@@ -1,46 +1,46 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TournamentMatchModel = void 0;
-const sequelize_1 = require("sequelize");
-class TournamentMatchModel extends sequelize_1.Model {
-    static initModel(sequelize) {
-        return TournamentMatchModel.init({
-            tournament_id: {
-                type: sequelize_1.DataTypes.UUID,
-                allowNull: false,
-                references: {
-                    model: 'Tournament',
-                    key: 'tournament_id'
-                }
-            },
-            match_id: {
-                type: sequelize_1.DataTypes.UUID,
-                allowNull: false,
-                primaryKey: true,
-                references: {
-                    model: 'Match',
-                    key: 'match_id'
-                }
-            },
-            index: {
-                type: sequelize_1.DataTypes.INTEGER,
-                allowNull: false
-            },
-            stage: {
-                type: sequelize_1.DataTypes.ENUM('FINAL', 'QUARTERFINALS', 'ROUND_OF_8', 'SEMIFINALS'),
-                allowNull: false
-            }
-        }, {
-            sequelize,
-            tableName: 'TournamentMatch',
-            schema: 'public',
-            timestamps: false,
-            indexes: [{
-                    name: 'TournamentMatch_match_id_uindex',
-                    unique: true,
-                    fields: [{ name: 'match_id' }]
-                }]
-        });
-    }
-}
-exports.TournamentMatchModel = TournamentMatchModel;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TournamentMatchModel = void 0;
+const sequelize_1 = require("sequelize");
+class TournamentMatchModel extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return TournamentMatchModel.init({
+            tournament_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'Tournament',
+                    key: 'tournament_id'
+                }
+            },
+            match_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'Match',
+                    key: 'match_id'
+                }
+            },
+            index: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false
+            },
+            stage: {
+                type: sequelize_1.DataTypes.ENUM('FINAL', 'QUARTERFINALS', 'ROUND_OF_8', 'SEMIFINALS'),
+                allowNull: false
+            }
+        }, {
+            sequelize,
+            tableName: 'TournamentMatch',
+            schema: 'public',
+            timestamps: false,
+            indexes: [{
+                    name: 'TournamentMatch_match_id_uindex',
+                    unique: true,
+                    fields: [{ name: 'match_id' }]
+                }]
+        });
+    }
+}
+exports.TournamentMatchModel = TournamentMatchModel;