volleyballsimtypes 0.0.162 → 0.0.164

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/competition-teams.js

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

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

@@ -0,0 +1,70 @@
+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 '.';
+import { Status } from '../common';
+export interface CompetitionAttributes {
+    competition_id: string;
+    iteration: number;
+    status: Status;
+    type: CompetitionType;
+    LeagueSeason?: LeagueSeasonAttributes;
+    CompetitionChampion?: CompetitionChampionAttributes;
+    CompetitionMatches?: CompetitionMatchAttributes[];
+    CompetitionTeams?: 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;
+    status: Status;
+    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,40 @@
+import { DataTypes, Model } from 'sequelize';
+import { StatusDataType } from '../common';
+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
+            },
+            status: {
+                type: StatusDataType,
+                allowNull: false,
+                defaultValue: 'PENDING'
+            }
+        }, {
+            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

@@ -0,0 +1,61 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { CoachId, CoachModel, LeagueId, LeagueModel, PlayerId, PlayerModel, TeamId, TeamModel } from '.';
+export interface CountryAttributes {
+    country_id: string;
+    name: string;
+    short_name: string;
+}
+export type CountryPk = 'country_id';
+export type CountryId = CountryModel[CountryPk];
+export type CountryCreationAttributes = CountryAttributes;
+export declare class CountryModel extends Model<CountryAttributes, CountryCreationAttributes> implements CountryAttributes {
+    country_id: string;
+    name: string;
+    short_name: string;
+    Coaches: CoachModel[];
+    getCoaches: Sequelize.HasManyGetAssociationsMixin<CoachModel>;
+    setCoaches: Sequelize.HasManySetAssociationsMixin<CoachModel, CoachId>;
+    addCoach: Sequelize.HasManyAddAssociationMixin<CoachModel, CoachId>;
+    addCoaches: Sequelize.HasManyAddAssociationsMixin<CoachModel, CoachId>;
+    createCoach: Sequelize.HasManyCreateAssociationMixin<CoachModel>;
+    removeCoach: Sequelize.HasManyRemoveAssociationMixin<CoachModel, CoachId>;
+    removeCoaches: Sequelize.HasManyRemoveAssociationsMixin<CoachModel, CoachId>;
+    hasCoach: Sequelize.HasManyHasAssociationMixin<CoachModel, CoachId>;
+    hasCoaches: Sequelize.HasManyHasAssociationsMixin<CoachModel, CoachId>;
+    countCoaches: Sequelize.HasManyCountAssociationsMixin;
+    Leagues: LeagueModel[];
+    getLeagues: Sequelize.HasManyGetAssociationsMixin<LeagueModel>;
+    setLeagues: Sequelize.HasManySetAssociationsMixin<LeagueModel, LeagueId>;
+    addLeague: Sequelize.HasManyAddAssociationMixin<LeagueModel, LeagueId>;
+    addLeagues: Sequelize.HasManyAddAssociationsMixin<LeagueModel, LeagueId>;
+    createLeague: Sequelize.HasManyCreateAssociationMixin<LeagueModel>;
+    removeLeague: Sequelize.HasManyRemoveAssociationMixin<LeagueModel, LeagueId>;
+    removeLeagues: Sequelize.HasManyRemoveAssociationsMixin<LeagueModel, LeagueId>;
+    hasLeague: Sequelize.HasManyHasAssociationMixin<LeagueModel, LeagueId>;
+    hasLeagues: Sequelize.HasManyHasAssociationsMixin<LeagueModel, LeagueId>;
+    countLeagues: Sequelize.HasManyCountAssociationsMixin;
+    Players: PlayerModel[];
+    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;
+    Teams: TeamModel[];
+    getTeams: Sequelize.HasManyGetAssociationsMixin<TeamModel>;
+    setTeams: Sequelize.HasManySetAssociationsMixin<TeamModel, TeamId>;
+    addTeam: Sequelize.HasManyAddAssociationMixin<TeamModel, TeamId>;
+    addTeams: Sequelize.HasManyAddAssociationsMixin<TeamModel, TeamId>;
+    createTeam: Sequelize.HasManyCreateAssociationMixin<TeamModel>;
+    removeTeam: Sequelize.HasManyRemoveAssociationMixin<TeamModel, TeamId>;
+    removeTeams: Sequelize.HasManyRemoveAssociationsMixin<TeamModel, TeamId>;
+    hasTeam: Sequelize.HasManyHasAssociationMixin<TeamModel, TeamId>;
+    hasTeams: Sequelize.HasManyHasAssociationsMixin<TeamModel, TeamId>;
+    countTeams: Sequelize.HasManyCountAssociationsMixin;
+    static initModel(sequelize: Sequelize.Sequelize): typeof CountryModel;
+}

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

@@ -0,0 +1,30 @@
+import { DataTypes, Model } from 'sequelize';
+export class CountryModel extends Model {
+    static initModel(sequelize) {
+        return CountryModel.init({
+            country_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true
+            },
+            name: {
+                type: DataTypes.STRING,
+                allowNull: false
+            },
+            short_name: {
+                type: DataTypes.STRING,
+                allowNull: false
+            }
+        }, {
+            sequelize,
+            tableName: 'Country',
+            schema: 'public',
+            timestamps: false,
+            indexes: [{
+                    name: 'Country_pk',
+                    unique: true,
+                    fields: [{ name: 'country_id' }]
+                }]
+        });
+    }
+}

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

@@ -0,0 +1,31 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+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 = 'player_id';
+export type DraftPickId = DraftPickModel[DraftPickPk];
+export type DraftPickCreationAttributes = DraftPickAttributes;
+export declare class DraftPickModel extends Model<DraftPickAttributes, DraftPickCreationAttributes> implements DraftPickAttributes {
+    draft_id: string;
+    team_id: string;
+    priority: number;
+    player_id: string;
+    draft: DraftModel;
+    getDraft: Sequelize.BelongsToGetAssociationMixin<DraftModel>;
+    setDraft: Sequelize.BelongsToSetAssociationMixin<DraftModel, DraftId>;
+    createDraft: Sequelize.BelongsToCreateAssociationMixin<DraftModel>;
+    player: PlayerModel;
+    getPlayer: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
+    setPlayer: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;
+    createPlayer: Sequelize.BelongsToCreateAssociationMixin<PlayerModel>;
+    team: TeamModel;
+    getTeam: Sequelize.BelongsToGetAssociationMixin<TeamModel>;
+    setTeam: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>;
+    createTeam: Sequelize.BelongsToCreateAssociationMixin<TeamModel>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof DraftPickModel;
+}

package/dist/esm/src/data/models/draft-pick.js

@@ -0,0 +1,46 @@
+import { DataTypes, Model } from 'sequelize';
+export class DraftPickModel extends Model {
+    static initModel(sequelize) {
+        return DraftPickModel.init({
+            draft_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'Draft',
+                    key: 'draft_id'
+                }
+            },
+            team_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'Team',
+                    key: 'team_id'
+                }
+            },
+            priority: {
+                type: DataTypes.INTEGER,
+                allowNull: false
+            },
+            player_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'Player',
+                    key: 'player_id'
+                }
+            }
+        }, {
+            sequelize,
+            tableName: 'DraftPick',
+            schema: 'public',
+            timestamps: false,
+            indexes: [{
+                    name: 'DraftPick_pk',
+                    unique: true,
+                    fields: [{ name: 'player_id' }]
+                }]
+        });
+    }
+}

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

@@ -0,0 +1,29 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { DraftPickAttributes, DraftPickId, DraftPickModel } from '.';
+export interface DraftAttributes {
+    draft_id: string;
+    start_date: Date;
+    end_date: Date;
+    DraftPicks?: DraftPickAttributes[];
+}
+export type DraftPk = 'draft_id';
+export type DraftId = DraftModel[DraftPk];
+export type DraftCreationAttributes = DraftAttributes;
+export declare class DraftModel extends Model<DraftAttributes, DraftCreationAttributes> implements DraftAttributes {
+    draft_id: string;
+    start_date: Date;
+    end_date: Date;
+    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;
+    static initModel(sequelize: Sequelize.Sequelize): typeof DraftModel;
+}

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

@@ -0,0 +1,30 @@
+import { DataTypes, Model } from 'sequelize';
+export class DraftModel extends Model {
+    static initModel(sequelize) {
+        return DraftModel.init({
+            draft_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true
+            },
+            start_date: {
+                type: DataTypes.DATEONLY,
+                allowNull: false
+            },
+            end_date: {
+                type: DataTypes.DATEONLY,
+                allowNull: false
+            }
+        }, {
+            sequelize,
+            tableName: 'Draft',
+            schema: 'public',
+            timestamps: false,
+            indexes: [{
+                    name: 'Draft_pk',
+                    unique: true,
+                    fields: [{ name: 'draft_id' }]
+                }]
+        });
+    }
+}

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

@@ -0,0 +1,25 @@
+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 './iteration';
+export * from './league';
+export * from './league-season';
+export * from './match';
+export * from './match-rating';
+export * from './match-result';
+export * from './match-set';
+export * from './match-set-stats';
+export * from './performance-stats';
+export * from './player';
+export * from './player-team';
+export * from './player-trait';
+export * from './rally';
+export * from './set-position';
+export * from './team';
+export * from './trait';
+export * from './user';

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

@@ -0,0 +1,25 @@
+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 './iteration';
+export * from './league';
+export * from './league-season';
+export * from './match';
+export * from './match-rating';
+export * from './match-result';
+export * from './match-set';
+export * from './match-set-stats';
+export * from './performance-stats';
+export * from './player';
+export * from './player-team';
+export * from './player-trait';
+export * from './rally';
+export * from './set-position';
+export * from './team';
+export * from './trait';
+export * from './user';

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

@@ -0,0 +1,26 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { CompetitionId, CompetitionModel } from '.';
+export interface IterationAttributes {
+    iteration_id: number;
+    start_date: Date;
+}
+export type IterationPk = 'iteration_id';
+export type IterationId = IterationModel[IterationPk];
+export type IterationCreationAttributes = IterationAttributes;
+export declare class IterationModel extends Model<IterationAttributes, IterationCreationAttributes> implements IterationAttributes {
+    iteration_id: number;
+    start_date: Date;
+    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

@@ -0,0 +1,26 @@
+import { DataTypes, Model } from 'sequelize';
+export class IterationModel extends Model {
+    static initModel(sequelize) {
+        return IterationModel.init({
+            iteration_id: {
+                type: DataTypes.INTEGER,
+                allowNull: false,
+                primaryKey: true
+            },
+            start_date: {
+                type: DataTypes.DATEONLY,
+                allowNull: false
+            }
+        }, {
+            sequelize,
+            tableName: 'Iteration',
+            schema: 'public',
+            timestamps: false,
+            indexes: [{
+                    name: 'Iteration_pk',
+                    unique: true,
+                    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;
+}

package/dist/esm/src/data/models/league-season.js

@@ -0,0 +1,34 @@
+import { DataTypes, Model } from 'sequelize';
+export class LeagueSeasonModel extends Model {
+    static initModel(sequelize) {
+        return LeagueSeasonModel.init({
+            league_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'League',
+                    key: 'league_id'
+                }
+            },
+            competition_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'Competition',
+                    key: 'competition_id'
+                }
+            }
+        }, {
+            sequelize,
+            tableName: 'LeagueSeason',
+            schema: 'public',
+            timestamps: false,
+            indexes: [{
+                    name: 'leagueseason_pk',
+                    unique: true,
+                    fields: [{ name: 'competition_id' }]
+                }]
+        });
+    }
+}

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

@@ -0,0 +1,44 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { CountryId, CountryModel, LeagueSeasonAttributes, LeagueSeasonId, LeagueSeasonModel, TeamId, TeamModel } from '.';
+export interface LeagueAttributes {
+    league_id: string;
+    country_id: string;
+    name: string;
+    LeagueSeasons?: LeagueSeasonAttributes[];
+}
+export type LeaguePk = 'league_id';
+export type LeagueId = LeagueModel[LeaguePk];
+export type LeagueCreationAttributes = LeagueAttributes;
+export declare class LeagueModel extends Model<LeagueAttributes, LeagueCreationAttributes> implements LeagueAttributes {
+    league_id: string;
+    country_id: string;
+    name: string;
+    country: CountryModel;
+    getCountry: Sequelize.BelongsToGetAssociationMixin<CountryModel>;
+    setCountry: Sequelize.BelongsToSetAssociationMixin<CountryModel, CountryId>;
+    createCountry: Sequelize.BelongsToCreateAssociationMixin<CountryModel>;
+    LeagueSeasons: LeagueSeasonModel[];
+    getLeagueSeasons: Sequelize.HasManyGetAssociationsMixin<LeagueSeasonModel>;
+    setLeagueSeasons: Sequelize.HasManySetAssociationsMixin<LeagueSeasonModel, LeagueSeasonId>;
+    addLeagueSeason: Sequelize.HasManyAddAssociationMixin<LeagueSeasonModel, LeagueSeasonId>;
+    addLeagueSeasons: Sequelize.HasManyAddAssociationsMixin<LeagueSeasonModel, LeagueSeasonId>;
+    createLeagueSeason: Sequelize.HasManyCreateAssociationMixin<LeagueSeasonModel>;
+    removeLeagueSeason: Sequelize.HasManyRemoveAssociationMixin<LeagueSeasonModel, LeagueSeasonId>;
+    removeLeagueSeasons: Sequelize.HasManyRemoveAssociationsMixin<LeagueSeasonModel, LeagueSeasonId>;
+    hasLeagueSeason: Sequelize.HasManyHasAssociationMixin<LeagueSeasonModel, LeagueSeasonId>;
+    hasLeagueSeasons: Sequelize.HasManyHasAssociationsMixin<LeagueSeasonModel, LeagueSeasonId>;
+    countLeagueSeasons: Sequelize.HasManyCountAssociationsMixin;
+    Teams: TeamModel[];
+    getTeams: Sequelize.HasManyGetAssociationsMixin<TeamModel>;
+    setTeams: Sequelize.HasManySetAssociationsMixin<TeamModel, TeamId>;
+    addTeam: Sequelize.HasManyAddAssociationMixin<TeamModel, TeamId>;
+    addTeams: Sequelize.HasManyAddAssociationsMixin<TeamModel, TeamId>;
+    createTeam: Sequelize.HasManyCreateAssociationMixin<TeamModel>;
+    removeTeam: Sequelize.HasManyRemoveAssociationMixin<TeamModel, TeamId>;
+    removeTeams: Sequelize.HasManyRemoveAssociationsMixin<TeamModel, TeamId>;
+    hasTeam: Sequelize.HasManyHasAssociationMixin<TeamModel, TeamId>;
+    hasTeams: Sequelize.HasManyHasAssociationsMixin<TeamModel, TeamId>;
+    countTeams: Sequelize.HasManyCountAssociationsMixin;
+    static initModel(sequelize: Sequelize.Sequelize): typeof LeagueModel;
+}

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

@@ -0,0 +1,34 @@
+import { DataTypes, Model } from 'sequelize';
+export class LeagueModel extends Model {
+    static initModel(sequelize) {
+        return LeagueModel.init({
+            league_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true
+            },
+            country_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'Country',
+                    key: 'country_id'
+                }
+            },
+            name: {
+                type: DataTypes.STRING,
+                allowNull: false
+            }
+        }, {
+            sequelize,
+            tableName: 'League',
+            schema: 'public',
+            timestamps: false,
+            indexes: [{
+                    name: 'League_pk',
+                    unique: true,
+                    fields: [{ name: 'league_id' }]
+                }]
+        });
+    }
+}