volleyballsimtypes 0.0.139 → 0.0.140

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

@@ -0,0 +1,3 @@
+export * from './models';
+export * from './transformers';
+export { initModels } from './init-models';

package/dist/esm/data/index.js

@@ -0,0 +1,3 @@
+export * from './models';
+export * from './transformers';
+export { initModels } from './init-models';

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

@@ -0,0 +1,2 @@
+import type { Sequelize } from 'sequelize';
+export declare function initModels(sequelize: Sequelize): any;

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

@@ -0,0 +1,194 @@
+import { CoachModel, CompetitionChampionModel, CompetitionMatchModel, CompetitionModel, CompetitionTeamsModel, CountryModel, DraftModel, DraftPickModel, IterationModel, LeagueModel, LeagueSeasonModel, MatchModel, MatchRatingModel, MatchSetModel, MatchSetStatsModel, PerformanceStatsModel, PlayerModel, PlayerTeamModel, PlayerTraitModel, RallyModel, SetPositionModel, TeamModel, TraitModel, UserModel } from './models';
+export function initModels(sequelize) {
+    const Coach = CoachModel.initModel(sequelize);
+    const Country = CountryModel.initModel(sequelize);
+    const Competition = CompetitionModel.initModel(sequelize);
+    const CompetitionTeams = CompetitionTeamsModel.initModel(sequelize);
+    const CompetitionChampion = CompetitionChampionModel.initModel(sequelize);
+    const CompetitionMatch = CompetitionMatchModel.initModel(sequelize);
+    const Draft = DraftModel.initModel(sequelize);
+    const DraftPick = DraftPickModel.initModel(sequelize);
+    const Iteration = IterationModel.initModel(sequelize);
+    const League = LeagueModel.initModel(sequelize);
+    const LeagueSeason = LeagueSeasonModel.initModel(sequelize);
+    const Match = MatchModel.initModel(sequelize);
+    const MatchRating = MatchRatingModel.initModel(sequelize);
+    const MatchSet = MatchSetModel.initModel(sequelize);
+    const MatchSetStats = MatchSetStatsModel.initModel(sequelize);
+    const PerformanceStats = PerformanceStatsModel.initModel(sequelize);
+    const Player = PlayerModel.initModel(sequelize);
+    const PlayerTeam = PlayerTeamModel.initModel(sequelize);
+    const PlayerTrait = PlayerTraitModel.initModel(sequelize);
+    const Rally = RallyModel.initModel(sequelize);
+    const SetPosition = SetPositionModel.initModel(sequelize);
+    const Team = TeamModel.initModel(sequelize);
+    const Trait = TraitModel.initModel(sequelize);
+    const User = UserModel.initModel(sequelize);
+    Coach.belongsTo(Country, { as: 'country', foreignKey: 'country_id' });
+    Coach.hasMany(Team, { as: 'Teams', foreignKey: 'coach_id' });
+    Competition.belongsTo(Iteration, { as: 'Iteration', foreignKey: 'iteration' });
+    Competition.hasMany(CompetitionMatch, { as: 'CompetitionMatches', foreignKey: 'competition_id' });
+    Competition.hasMany(CompetitionTeams, { as: 'CompetitionTeams', foreignKey: 'competition_id' });
+    Competition.hasOne(CompetitionChampion, { as: 'CompetitionChampion', foreignKey: 'competition_id' });
+    Competition.hasOne(LeagueSeason, { as: 'LeagueSeason', foreignKey: 'competition_id' });
+    Competition.belongsToMany(Team, {
+        as: 'Teams',
+        through: CompetitionTeams,
+        foreignKey: 'competition_id',
+        otherKey: 'team_id'
+    });
+    CompetitionChampion.belongsTo(Competition, { as: 'competition', foreignKey: 'competition_id' });
+    CompetitionChampion.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
+    CompetitionMatch.belongsTo(Competition, { as: 'Competition', foreignKey: 'competition_id' });
+    CompetitionMatch.belongsTo(Match, { as: 'Match', foreignKey: 'match_id' });
+    CompetitionTeams.belongsTo(Competition, { as: 'competition', foreignKey: 'competition_id' });
+    CompetitionTeams.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
+    Country.hasMany(Coach, { as: 'Coaches', foreignKey: 'country_id' });
+    Country.hasMany(League, { as: 'Leagues', foreignKey: 'country_id' });
+    Country.hasMany(Player, { as: 'Players', foreignKey: 'country_id' });
+    Country.hasMany(Team, { as: 'Teams', foreignKey: 'country_id' });
+    Draft.hasMany(DraftPick, { as: 'DraftPicks', foreignKey: 'draft_id' });
+    DraftPick.belongsTo(Draft, { as: 'draft', foreignKey: 'draft_id' });
+    DraftPick.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
+    DraftPick.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
+    Iteration.hasMany(Competition, { as: 'Competitions', foreignKey: 'iteration' });
+    League.belongsTo(Country, { as: 'country', foreignKey: 'country_id' });
+    League.hasMany(LeagueSeason, { as: 'LeagueSeasons', foreignKey: 'league_id' });
+    League.hasMany(Team, { as: 'Teams', foreignKey: 'league_id' });
+    LeagueSeason.belongsTo(Competition, { as: 'competition', foreignKey: 'competition_id' });
+    LeagueSeason.belongsTo(League, { as: 'league', foreignKey: 'league_id' });
+    Match.belongsTo(Team, { as: 'AwayTeam', foreignKey: 'away_team' });
+    Match.belongsTo(Team, { as: 'HomeTeam', foreignKey: 'home_team' });
+    Match.belongsToMany(Team, {
+        as: 'TeamMatchRatings',
+        through: MatchRating,
+        foreignKey: 'match_id',
+        otherKey: 'team_id'
+    });
+    Match.hasMany(MatchRating, { as: 'MatchRatings', foreignKey: 'match_id' });
+    Match.hasMany(MatchSet, { as: 'MatchSets', foreignKey: 'match_id' });
+    Match.hasOne(CompetitionMatch, { as: 'CompetitionMatch', foreignKey: 'match_id' });
+    MatchRating.belongsTo(Match, { as: 'match', foreignKey: 'match_id' });
+    MatchRating.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
+    MatchSet.belongsTo(Match, { as: 'match', foreignKey: 'match_id' });
+    MatchSet.belongsToMany(Player, {
+        as: 'SetPositionsPlayer',
+        through: SetPosition,
+        foreignKey: 'match_set_id',
+        otherKey: 'player_id'
+    });
+    MatchSet.belongsToMany(Player, {
+        as: 'SetStatsPlayers',
+        through: MatchSetStats,
+        foreignKey: 'match_set_id',
+        otherKey: 'player_id'
+    });
+    MatchSet.hasMany(MatchSetStats, { as: 'MatchSetStats', foreignKey: 'match_set_id' });
+    MatchSet.hasMany(Rally, { as: 'Rallies', foreignKey: 'match_set_id' });
+    MatchSet.hasMany(SetPosition, { as: 'SetPositions', foreignKey: 'match_set_id' });
+    MatchSetStats.belongsTo(MatchSet, { as: 'matchSet', foreignKey: 'match_set_id' });
+    MatchSetStats.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
+    PerformanceStats.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
+    Player.belongsTo(Country, { as: 'country', foreignKey: 'country_id' });
+    Player.belongsToMany(MatchSet, {
+        as: 'SetPositionSets',
+        through: SetPosition,
+        foreignKey: 'player_id',
+        otherKey: 'match_set_id'
+    });
+    Player.belongsToMany(MatchSet, {
+        as: 'StatsMatchSets',
+        through: MatchSetStats,
+        foreignKey: 'player_id',
+        otherKey: 'match_set_id'
+    });
+    Player.belongsToMany(Team, {
+        as: 'Teams',
+        through: PlayerTeam,
+        foreignKey: 'player_id',
+        otherKey: 'team_id'
+    });
+    Player.belongsToMany(Trait, {
+        as: 'Traits',
+        through: PlayerTrait,
+        foreignKey: 'player_id',
+        otherKey: 'trait_id'
+    });
+    Player.hasMany(MatchSetStats, { as: 'MatchSetStats', foreignKey: 'player_id' });
+    Player.hasMany(PlayerTeam, { as: 'PlayerTeams', foreignKey: 'player_id' });
+    Player.hasMany(PlayerTrait, { as: 'PlayerTraits', foreignKey: 'player_id' });
+    Player.hasMany(SetPosition, { as: 'SetPositions', foreignKey: 'player_id' });
+    Player.hasOne(DraftPick, { as: 'DraftPick', foreignKey: 'player_id' });
+    Player.hasOne(PerformanceStats, { as: 'PerformanceStat', foreignKey: 'player_id' });
+    PlayerTeam.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
+    PlayerTeam.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
+    PlayerTrait.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
+    PlayerTrait.belongsTo(Trait, { as: 'trait', foreignKey: 'trait_id' });
+    Rally.belongsTo(MatchSet, { as: 'matchSet', foreignKey: 'match_set_id' });
+    Rally.belongsTo(Team, { as: 'ServingTeam', foreignKey: 'serving_team' });
+    SetPosition.belongsTo(MatchSet, { as: 'matchSet', foreignKey: 'match_set_id' });
+    SetPosition.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
+    Team.belongsTo(Coach, { as: 'coach', foreignKey: 'coach_id' });
+    Team.belongsTo(Country, { as: 'country', foreignKey: 'country_id' });
+    Team.belongsTo(League, { as: 'league', foreignKey: 'league_id' });
+    Team.belongsToMany(Competition, {
+        as: 'Competitions',
+        through: CompetitionTeams,
+        foreignKey: 'team_id',
+        otherKey: 'competition_id'
+    });
+    Team.belongsToMany(Match, {
+        as: 'RatingMatches',
+        through: MatchRating,
+        foreignKey: 'team_id',
+        otherKey: 'match_id'
+    });
+    Team.belongsToMany(Player, {
+        as: 'Players',
+        through: PlayerTeam,
+        foreignKey: 'team_id',
+        otherKey: 'player_id'
+    });
+    Team.hasMany(CompetitionChampion, { as: 'CompetitionChampions', foreignKey: 'team_id' });
+    Team.hasMany(CompetitionTeams, { as: 'CompetitionTeams', foreignKey: 'team_id' });
+    Team.hasMany(DraftPick, { as: 'DraftPicks', foreignKey: 'team_id' });
+    Team.hasMany(Match, { as: 'HomeMatches', foreignKey: 'home_team' });
+    Team.hasMany(Match, { as: 'AwayMatches', foreignKey: 'away_team' });
+    Team.hasMany(MatchRating, { as: 'MatchRatings', foreignKey: 'team_id' });
+    Team.hasMany(PlayerTeam, { as: 'PlayerTeams', foreignKey: 'team_id' });
+    Team.hasMany(Rally, { as: 'Rallies', foreignKey: 'serving_team' });
+    Trait.belongsToMany(Player, {
+        as: 'Players',
+        through: PlayerTrait,
+        foreignKey: 'trait_id',
+        otherKey: 'player_id'
+    });
+    Trait.hasMany(PlayerTrait, { as: 'PlayerTraits', foreignKey: 'trait_id' });
+    return {
+        Coach,
+        Competition,
+        CompetitionChampion,
+        CompetitionMatch,
+        CompetitionTeams,
+        Country,
+        Draft,
+        DraftPick,
+        Event,
+        Iteration,
+        League,
+        LeagueSeason,
+        Match,
+        MatchRating,
+        MatchSet,
+        MatchSetStats,
+        PerformanceStats,
+        Player,
+        PlayerTeam,
+        PlayerTrait,
+        Rally,
+        SetPosition,
+        Team,
+        Trait,
+        User
+    };
+}

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

@@ -0,0 +1,40 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import { CountryId, CountryModel, TeamId, TeamModel } from '.';
+export interface CoachAttributes {
+    coach_id: string;
+    formation: FormationType;
+    substitution_tolerance: number;
+    first_name: string;
+    last_name: string;
+    country_id: string;
+}
+export type FormationType = '4-2' | '5-1' | '6-2';
+export type CoachPk = 'coach_id';
+export type CoachId = CoachModel[CoachPk];
+export type CoachOptionalAttributes = 'substitution_tolerance';
+export type CoachCreationAttributes = Optional<CoachAttributes, CoachOptionalAttributes>;
+export declare class CoachModel extends Model<CoachAttributes, CoachCreationAttributes> implements CoachAttributes {
+    coach_id: string;
+    formation: FormationType;
+    substitution_tolerance: number;
+    first_name: string;
+    last_name: string;
+    country_id: string;
+    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;
+    country: CountryModel;
+    getCountry: Sequelize.BelongsToGetAssociationMixin<CountryModel>;
+    setCountry: Sequelize.BelongsToSetAssociationMixin<CountryModel, CountryId>;
+    createCountry: Sequelize.BelongsToCreateAssociationMixin<CountryModel>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof CoachModel;
+}

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

@@ -0,0 +1,51 @@
+import { DataTypes, Model } from 'sequelize';
+export class CoachModel extends Model {
+    static initModel(sequelize) {
+        return CoachModel.init({
+            coach_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true
+            },
+            formation: {
+                type: DataTypes.ENUM('4-2', '5-1', '6-2'),
+                allowNull: false
+            },
+            substitution_tolerance: {
+                type: DataTypes.REAL,
+                allowNull: false,
+                defaultValue: 0
+            },
+            first_name: {
+                type: DataTypes.STRING,
+                allowNull: false
+            },
+            last_name: {
+                type: DataTypes.STRING,
+                allowNull: false
+            },
+            country_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'Country',
+                    key: 'country_id'
+                }
+            }
+        }, {
+            sequelize,
+            tableName: 'Coach',
+            schema: 'public',
+            timestamps: false,
+            indexes: [
+                {
+                    name: 'Coach_pk',
+                    unique: true,
+                    fields: [
+                        { name: 'coach_id' }
+                    ]
+                }
+            ]
+        });
+    }
+}

package/dist/esm/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/data/models/competition-champion.js

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

package/dist/esm/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/data/models/competition-match.js

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

package/dist/esm/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/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/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;
+    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;
+    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/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/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;
+}