volleyballsimtypes 0.0.100 → 0.0.102

package/dist/esm/src/data/models/competition-champion.d.ts

@@ -0,0 +1,23 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { CompetitionId, CompetitionModel, TeamId, TeamModel } from '.';
+export interface CompetitionChampionAttributes {
+    competition_id: string;
+    team_id: string;
+}
+export type CompetitionChampionPk = 'competition_id';
+export type CompetitionChampionId = CompetitionChampionModel[CompetitionChampionPk];
+export type CompetitionChampionCreationAttributes = CompetitionChampionAttributes;
+export declare class CompetitionChampionModel extends Model<CompetitionChampionAttributes, CompetitionChampionCreationAttributes> implements CompetitionChampionAttributes {
+    competition_id: string;
+    team_id: string;
+    competition: CompetitionModel;
+    getCompetition: Sequelize.BelongsToGetAssociationMixin<CompetitionModel>;
+    setCompetition: Sequelize.BelongsToSetAssociationMixin<CompetitionModel, CompetitionId>;
+    createCompetition: Sequelize.BelongsToCreateAssociationMixin<CompetitionModel>;
+    team: TeamModel;
+    getTeam: Sequelize.BelongsToGetAssociationMixin<TeamModel>;
+    setTeam: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>;
+    createTeam: Sequelize.BelongsToCreateAssociationMixin<TeamModel>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof CompetitionChampionModel;
+}

package/dist/esm/src/data/models/{tournament-teams.js → competition-champion.js}

@@ -1,20 +1,19 @@
 import { DataTypes, Model } from 'sequelize';
-export class TournamentTeamsModel extends Model {
+export class CompetitionChampionModel extends Model {
     static initModel(sequelize) {
-        return TournamentTeamsModel.init({
-            tournament_id: {
+        return CompetitionChampionModel.init({
+            competition_id: {
                 type: DataTypes.UUID,
                 allowNull: false,
                 primaryKey: true,
                 references: {
-                    model: 'Tournament',
-                    key: 'tournament_id'
+                    model: 'Competition',
+                    key: 'competition_id'
                 }
             },
             team_id: {
                 type: DataTypes.UUID,
                 allowNull: false,
-                primaryKey: true,
                 references: {
                     model: 'Team',
                     key: 'team_id'
@@ -22,19 +21,14 @@ export class TournamentTeamsModel extends Model {
             }
         }, {
             sequelize,
-            tableName: 'TournamentTeams',
+            tableName: 'CompetitionChampion',
             schema: 'public',
             timestamps: false,
-            indexes: [
-                {
-                    name: 'TournamentTeams_pk',
+            indexes: [{
+                    name: 'competitionchampion_pk',
                     unique: true,
-                    fields: [
-                        { name: 'tournament_id' },
-                        { name: 'team_id' }
-                    ]
-                }
-            ]
+                    fields: [{ name: 'competition_id' }]
+                }]
         });
     }
 }

package/dist/esm/src/data/models/competition-match.d.ts

@@ -0,0 +1,29 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { CompetitionId, CompetitionModel, MatchAttributes, MatchId, MatchModel } from '.';
+export interface CompetitionMatchAttributes {
+    competition_id: string;
+    match_id: string;
+    index: number;
+    stage: CompetitionStage;
+    match?: MatchAttributes;
+}
+export type CompetitionMatchPk = 'match_id';
+export type CompetitionMatchId = CompetitionMatchModel[CompetitionMatchPk];
+export type CompetitionMatchCreationAttributes = CompetitionMatchAttributes;
+export type CompetitionStage = 'FINAL' | 'LEAGUE' | 'QUARTERFINALS' | 'ROUND_OF_8' | 'SEMIFINALS';
+export declare class CompetitionMatchModel extends Model<CompetitionMatchAttributes, CompetitionMatchCreationAttributes> implements CompetitionMatchAttributes {
+    competition_id: string;
+    match_id: string;
+    index: number;
+    stage: CompetitionStage;
+    Competition: CompetitionModel;
+    getCompetition: Sequelize.BelongsToGetAssociationMixin<CompetitionModel>;
+    setCompetition: Sequelize.BelongsToSetAssociationMixin<CompetitionModel, CompetitionId>;
+    createCompetition: Sequelize.BelongsToCreateAssociationMixin<CompetitionModel>;
+    Match: MatchModel;
+    getMatch: Sequelize.BelongsToGetAssociationMixin<MatchModel>;
+    setMatch: Sequelize.BelongsToSetAssociationMixin<MatchModel, MatchId>;
+    createMatch: Sequelize.BelongsToCreateAssociationMixin<MatchModel>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof CompetitionMatchModel;
+}

package/dist/esm/src/data/models/{tournament-match.js → competition-match.js}

@@ -1,13 +1,13 @@
 import { DataTypes, Model } from 'sequelize';
-export class TournamentMatchModel extends Model {
+export class CompetitionMatchModel extends Model {
     static initModel(sequelize) {
-        return TournamentMatchModel.init({
-            tournament_id: {
+        return CompetitionMatchModel.init({
+            competition_id: {
                 type: DataTypes.UUID,
                 allowNull: false,
                 references: {
-                    model: 'Tournament',
-                    key: 'tournament_id'
+                    model: 'Competition',
+                    key: 'competition_id'
                 }
             },
             match_id: {
@@ -24,16 +24,16 @@ export class TournamentMatchModel extends Model {
                 allowNull: false
             },
             stage: {
-                type: DataTypes.ENUM('FINAL', 'QUARTERFINALS', 'ROUND_OF_8', 'SEMIFINALS'),
+                type: DataTypes.ENUM('FINAL', 'LEAGUE', 'QUARTERFINALS', 'ROUND_OF_8', 'SEMIFINALS'),
                 allowNull: false
             }
         }, {
             sequelize,
-            tableName: 'TournamentMatch',
+            tableName: 'CompetitionMatch',
             schema: 'public',
             timestamps: false,
             indexes: [{
-                    name: 'TournamentMatch_match_id_uindex',
+                    name: 'competitionmatch_pk',
                     unique: true,
                     fields: [{ name: 'match_id' }]
                 }]

package/dist/esm/src/data/models/competition-teams.d.ts

@@ -0,0 +1,23 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { CompetitionId, CompetitionModel, TeamId, TeamModel } from '.';
+export interface CompetitionTeamsAttributes {
+    competition_id: string;
+    team_id: string;
+}
+export type CompetitionTeamsPk = 'competition_id' | 'team_id';
+export type CompetitionTeamsId = CompetitionTeamsModel[CompetitionTeamsPk];
+export type CompetitionTeamsCreationAttributes = CompetitionTeamsAttributes;
+export declare class CompetitionTeamsModel extends Model<CompetitionTeamsAttributes, CompetitionTeamsCreationAttributes> implements CompetitionTeamsAttributes {
+    competition_id: string;
+    team_id: string;
+    competition: CompetitionModel;
+    getCompetition: Sequelize.BelongsToGetAssociationMixin<CompetitionModel>;
+    setCompetition: Sequelize.BelongsToSetAssociationMixin<CompetitionModel, CompetitionId>;
+    createCompetition: Sequelize.BelongsToCreateAssociationMixin<CompetitionModel>;
+    team: TeamModel;
+    getTeam: Sequelize.BelongsToGetAssociationMixin<TeamModel>;
+    setTeam: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>;
+    createTeam: Sequelize.BelongsToCreateAssociationMixin<TeamModel>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof CompetitionTeamsModel;
+}

package/dist/esm/src/data/models/{season-teams.js → competition-teams.js}

@@ -1,14 +1,14 @@
 import { DataTypes, Model } from 'sequelize';
-export class SeasonTeamsModel extends Model {
+export class CompetitionTeamsModel extends Model {
     static initModel(sequelize) {
-        return SeasonTeamsModel.init({
-            season_id: {
+        return CompetitionTeamsModel.init({
+            competition_id: {
                 type: DataTypes.UUID,
                 allowNull: false,
                 primaryKey: true,
                 references: {
-                    model: 'Season',
-                    key: 'season_id'
+                    model: 'Competition',
+                    key: 'competition_id'
                 }
             },
             team_id: {
@@ -22,19 +22,17 @@ export class SeasonTeamsModel extends Model {
             }
         }, {
             sequelize,
-            tableName: 'SeasonTeams',
+            tableName: 'CompetitionTeams',
             schema: 'public',
             timestamps: false,
-            indexes: [
-                {
-                    name: 'SeasonTeams_pk',
+            indexes: [{
+                    name: 'competitionteams_pk',
                     unique: true,
                     fields: [
-                        { name: 'season_id' },
+                        { name: 'competition_id' },
                         { name: 'team_id' }
                     ]
-                }
-            ]
+                }]
         });
     }
 }

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

@@ -0,0 +1,67 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { CompetitionChampionAttributes, CompetitionChampionId, CompetitionChampionModel, CompetitionMatchAttributes, CompetitionMatchId, CompetitionMatchModel, CompetitionTeamsAttributes, CompetitionTeamsId, CompetitionTeamsModel, IterationId, IterationModel, LeagueSeasonAttributes, LeagueSeasonId, LeagueSeasonModel, TeamId, TeamModel } from '.';
+export interface CompetitionAttributes {
+    competition_id: string;
+    iteration: number;
+    type: CompetitionType;
+    leagueSeason?: LeagueSeasonAttributes;
+    champion?: CompetitionChampionAttributes;
+    matches?: CompetitionMatchAttributes[];
+    teams?: CompetitionTeamsAttributes[];
+}
+export type CompetitionPk = 'competition_id';
+export type CompetitionType = 'LEAGUE' | 'TOURNAMENT';
+export type CompetitionId = CompetitionModel[CompetitionPk];
+export type CompetitionCreationAttributes = CompetitionAttributes;
+export declare class CompetitionModel extends Model<CompetitionAttributes, CompetitionCreationAttributes> implements CompetitionAttributes {
+    competition_id: string;
+    iteration: number;
+    type: CompetitionType;
+    CompetitionChampion: CompetitionChampionModel;
+    getCompetitionChampion: Sequelize.HasOneGetAssociationMixin<CompetitionChampionModel>;
+    setCompetitionChampion: Sequelize.HasOneSetAssociationMixin<CompetitionChampionModel, CompetitionChampionId>;
+    createCompetitionChampion: Sequelize.HasOneCreateAssociationMixin<CompetitionChampionModel>;
+    CompetitionMatches: CompetitionMatchModel[];
+    getCompetitionMatches: Sequelize.HasManyGetAssociationsMixin<CompetitionMatchModel>;
+    setCompetitionMatches: Sequelize.HasManySetAssociationsMixin<CompetitionMatchModel, CompetitionMatchId>;
+    addCompetitionMatch: Sequelize.HasManyAddAssociationMixin<CompetitionMatchModel, CompetitionMatchId>;
+    addCompetitionMatches: Sequelize.HasManyAddAssociationsMixin<CompetitionMatchModel, CompetitionMatchId>;
+    createCompetitionMatch: Sequelize.HasManyCreateAssociationMixin<CompetitionMatchModel>;
+    removeCompetitionMatch: Sequelize.HasManyRemoveAssociationMixin<CompetitionMatchModel, CompetitionMatchId>;
+    removeCompetitionMatches: Sequelize.HasManyRemoveAssociationsMixin<CompetitionMatchModel, CompetitionMatchId>;
+    hasCompetitionMatch: Sequelize.HasManyHasAssociationMixin<CompetitionMatchModel, CompetitionMatchId>;
+    hasCompetitionMatches: Sequelize.HasManyHasAssociationsMixin<CompetitionMatchModel, CompetitionMatchId>;
+    countCompetitionMatches: 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;
+    LeagueSeason: LeagueSeasonModel;
+    getLeagueSeason: Sequelize.HasOneGetAssociationMixin<LeagueSeasonModel>;
+    setLeagueSeason: Sequelize.HasOneSetAssociationMixin<LeagueSeasonModel, LeagueSeasonId>;
+    createLeagueSeason: Sequelize.HasOneCreateAssociationMixin<LeagueSeasonModel>;
+    Teams: TeamModel[];
+    getTeams: Sequelize.BelongsToManyGetAssociationsMixin<TeamModel>;
+    setTeams: Sequelize.BelongsToManySetAssociationsMixin<TeamModel, TeamId>;
+    addTeam: Sequelize.BelongsToManyAddAssociationMixin<TeamModel, TeamId>;
+    addTeams: Sequelize.BelongsToManyAddAssociationsMixin<TeamModel, TeamId>;
+    createTeam: Sequelize.BelongsToManyCreateAssociationMixin<TeamModel>;
+    removeTeam: Sequelize.BelongsToManyRemoveAssociationMixin<TeamModel, TeamId>;
+    removeTeams: Sequelize.BelongsToManyRemoveAssociationsMixin<TeamModel, TeamId>;
+    hasTeam: Sequelize.BelongsToManyHasAssociationMixin<TeamModel, TeamId>;
+    hasTeams: Sequelize.BelongsToManyHasAssociationsMixin<TeamModel, TeamId>;
+    countTeams: Sequelize.BelongsToManyCountAssociationsMixin;
+    Iteration: IterationModel;
+    getIteration: Sequelize.BelongsToGetAssociationMixin<IterationModel>;
+    setIteration: Sequelize.BelongsToSetAssociationMixin<IterationModel, IterationId>;
+    createIteration: Sequelize.BelongsToCreateAssociationMixin<IterationModel>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof CompetitionModel;
+}

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

@@ -0,0 +1,34 @@
+import { DataTypes, Model } from 'sequelize';
+export class CompetitionModel extends Model {
+    static initModel(sequelize) {
+        return CompetitionModel.init({
+            competition_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true
+            },
+            iteration: {
+                type: DataTypes.INTEGER,
+                allowNull: false,
+                references: {
+                    model: 'Iteration',
+                    key: 'iteration_id'
+                }
+            },
+            type: {
+                type: DataTypes.ENUM('LEAGUE', 'TOURNAMENT'),
+                allowNull: false
+            }
+        }, {
+            sequelize,
+            tableName: 'Competition',
+            schema: 'public',
+            timestamps: false,
+            indexes: [{
+                    name: 'competition_pk',
+                    unique: true,
+                    fields: [{ name: 'competition_id' }]
+                }]
+        });
+    }
+}

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

@@ -1,6 +1,6 @@
 import * as Sequelize from 'sequelize';
 import { Model } from 'sequelize';
-import type { CoachId, CoachModel, LeagueId, LeagueModel, PlayerId, PlayerModel, TeamId, TeamModel } from '.';
+import { CoachId, CoachModel, LeagueId, LeagueModel, PlayerId, PlayerModel, TeamId, TeamModel } from '.';
 export interface CountryAttributes {
     country_id: string;
     name: string;

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

@@ -8,29 +8,23 @@ export class CountryModel extends Model {
                 primaryKey: true
             },
             name: {
-                type: DataTypes.STRING(50),
-                allowNull: false,
-                unique: true
+                type: DataTypes.STRING,
+                allowNull: false
             },
             short_name: {
                 type: DataTypes.STRING,
-                allowNull: false,
-                unique: true
+                allowNull: false
             }
         }, {
             sequelize,
             tableName: 'Country',
             schema: 'public',
             timestamps: false,
-            indexes: [
-                {
+            indexes: [{
                     name: 'Country_pk',
                     unique: true,
-                    fields: [
-                        { name: 'country_id' }
-                    ]
-                }
-            ]
+                    fields: [{ name: 'country_id' }]
+                }]
         });
     }
 }

package/dist/esm/src/data/models/draft-pick.d.ts

@@ -1,14 +1,13 @@
 import * as Sequelize from 'sequelize';
 import { Model } from 'sequelize';
-import type { DraftId, PlayerId, TeamId } from '.';
-import { DraftModel, PlayerModel, TeamModel } from '.';
+import type { DraftId, DraftModel, PlayerId, PlayerModel, TeamId, TeamModel } from '.';
 export interface DraftPickAttributes {
     draft_id: string;
     team_id: string;
     priority: number;
     player_id: string;
 }
-export type DraftPickPk = 'draft_id' | 'team_id';
+export type DraftPickPk = 'player_id';
 export type DraftPickId = DraftPickModel[DraftPickPk];
 export type DraftPickCreationAttributes = DraftPickAttributes;
 export declare class DraftPickModel extends Model<DraftPickAttributes, DraftPickCreationAttributes> implements DraftPickAttributes {

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

@@ -1,7 +1,6 @@
 import * as Sequelize from 'sequelize';
 import { Model } from 'sequelize';
-import type { DraftPickAttributes, DraftPickId } from '.';
-import { DraftPickModel } from '.';
+import { DraftPickAttributes, DraftPickId, DraftPickModel } from '.';
 export interface DraftAttributes {
     draft_id: string;
     start_date: Date;

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

@@ -4,11 +4,11 @@ import { PlayerId, PlayerModel, RallyId, RallyModel } from '.';
 export interface EventAttributes {
     event_id: string;
     rally_id: string;
-    event_type: EventType;
     order: number;
     player_id: string;
+    event_type: EventType;
 }
-export type EventType = 'LIBERO_REPLACEMENT' | 'SUBSTITUTION' | 'SERVE' | 'RECEPTION' | 'SET' | 'SPIKE' | 'BLOCK' | 'SCORE';
+export type EventType = 'LIBERO_REPLACEMENT' | 'SUBSTITUTION' | 'SERVE' | 'RECEPTION' | 'SET' | 'SPIKE' | 'BLOCK';
 export type CourtTarget = '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';
 export type EventPk = 'event_id';
 export type EventId = EventModel[EventPk];
@@ -16,9 +16,9 @@ export type EventCreationAttributes = EventAttributes;
 export declare class EventModel extends Model<EventAttributes, EventCreationAttributes> implements EventAttributes {
     event_id: string;
     rally_id: string;
-    event_type: EventType;
     order: number;
     player_id: string;
+    event_type: EventType;
     player: PlayerModel;
     getPlayer: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
     setPlayer: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;

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

@@ -15,10 +15,6 @@ export class EventModel extends Model {
                     key: 'rally_id'
                 }
             },
-            event_type: {
-                type: DataTypes.ENUM('LIBERO_REPLACEMENT', 'SUBSTITUTION', 'SERVE', 'RECEPTION', 'SET', 'SPIKE', 'BLOCK', 'SCORE'),
-                allowNull: false
-            },
             order: {
                 type: DataTypes.INTEGER,
                 allowNull: false
@@ -30,6 +26,10 @@ export class EventModel 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/index.d.ts

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

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

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

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

@@ -1,6 +1,6 @@
 import * as Sequelize from 'sequelize';
 import { Model } from 'sequelize';
-import { SeasonId, SeasonModel, TournamentId, TournamentModel } from '.';
+import { CompetitionId, CompetitionModel } from '.';
 export interface IterationAttributes {
     iteration_id: number;
     start_date: Date;
@@ -11,27 +11,16 @@ export type IterationCreationAttributes = IterationAttributes;
 export declare class IterationModel extends Model<IterationAttributes, IterationCreationAttributes> implements IterationAttributes {
     iteration_id: number;
     start_date: Date;
-    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;
-    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;
+    Competitions: CompetitionModel[];
+    getCompetitions: Sequelize.HasManyGetAssociationsMixin<CompetitionModel>;
+    setCompetitions: Sequelize.HasManySetAssociationsMixin<CompetitionModel, CompetitionId>;
+    addCompetition: Sequelize.HasManyAddAssociationMixin<CompetitionModel, CompetitionId>;
+    addCompetitions: Sequelize.HasManyAddAssociationsMixin<CompetitionModel, CompetitionId>;
+    createCompetition: Sequelize.HasManyCreateAssociationMixin<CompetitionModel>;
+    removeCompetition: Sequelize.HasManyRemoveAssociationMixin<CompetitionModel, CompetitionId>;
+    removeCompetitions: Sequelize.HasManyRemoveAssociationsMixin<CompetitionModel, CompetitionId>;
+    hasCompetition: Sequelize.HasManyHasAssociationMixin<CompetitionModel, CompetitionId>;
+    hasCompetitions: Sequelize.HasManyHasAssociationsMixin<CompetitionModel, CompetitionId>;
+    countCompetitions: Sequelize.HasManyCountAssociationsMixin;
     static initModel(sequelize: Sequelize.Sequelize): typeof IterationModel;
 }

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

@@ -3,8 +3,6 @@ export class IterationModel extends Model {
     static initModel(sequelize) {
         return IterationModel.init({
             iteration_id: {
-                autoIncrement: true,
-                autoIncrementIdentity: true,
                 type: DataTypes.INTEGER,
                 allowNull: false,
                 primaryKey: true
@@ -18,15 +16,11 @@ export class IterationModel extends Model {
             tableName: 'Iteration',
             schema: 'public',
             timestamps: false,
-            indexes: [
-                {
+            indexes: [{
                     name: 'Iteration_pk',
                     unique: true,
-                    fields: [
-                        { name: 'iteration_id' },
-                    ]
-                },
-            ]
+                    fields: [{ name: 'iteration_id' }]
+                }]
         });
     }
 }

package/dist/esm/src/data/models/league-season.d.ts

@@ -0,0 +1,23 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { CompetitionId, CompetitionModel, LeagueId, LeagueModel } from '.';
+export interface LeagueSeasonAttributes {
+    league_id: string;
+    competition_id: string;
+}
+export type LeagueSeasonPk = 'competition_id';
+export type LeagueSeasonId = LeagueSeasonModel[LeagueSeasonPk];
+export type LeagueSeasonCreationAttributes = LeagueSeasonAttributes;
+export declare class LeagueSeasonModel extends Model<LeagueSeasonAttributes, LeagueSeasonCreationAttributes> implements LeagueSeasonAttributes {
+    league_id: string;
+    competition_id: string;
+    competition: CompetitionModel;
+    getCompetition: Sequelize.BelongsToGetAssociationMixin<CompetitionModel>;
+    setCompetition: Sequelize.BelongsToSetAssociationMixin<CompetitionModel, CompetitionId>;
+    createCompetition: Sequelize.BelongsToCreateAssociationMixin<CompetitionModel>;
+    league: LeagueModel;
+    getLeague: Sequelize.BelongsToGetAssociationMixin<LeagueModel>;
+    setLeague: Sequelize.BelongsToSetAssociationMixin<LeagueModel, LeagueId>;
+    createLeague: Sequelize.BelongsToCreateAssociationMixin<LeagueModel>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof LeagueSeasonModel;
+}