volleyballsimtypes 0.0.138 → 0.0.140

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

@@ -0,0 +1,124 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { CountryId, CountryModel, DraftPickId, DraftPickModel, MatchSetId, MatchSetModel, MatchSetStatsAttributes, MatchSetStatsId, MatchSetStatsModel, PerformanceStatsAttributes, PerformanceStatsId, PerformanceStatsModel, PlayerTeamId, PlayerTeamModel, PlayerTraitId, PlayerTraitModel, SetPositionId, SetPositionModel, TeamId, TeamModel, TraitId, TraitModel } from '.';
+export interface PlayerAttributes {
+    player_id: string;
+    roles: RoleType[];
+    first_name: string;
+    last_name: string;
+    country_id: string;
+    PerformanceStat?: PerformanceStatsAttributes;
+    MatchSetStats?: MatchSetStatsAttributes[];
+}
+export type PlayerPk = 'player_id';
+export type RoleType = 'SETTER' | 'LIBERO' | 'OUTSIDE_HITTER' | 'OPPOSITE_HITTER' | 'MIDDLE_BLOCKER' | 'DEFENSIVE_SPECIALIST';
+export type PlayerId = PlayerModel[PlayerPk];
+export type PlayerCreationAttributes = PlayerAttributes;
+export declare class PlayerModel extends Model<PlayerAttributes, PlayerCreationAttributes> implements PlayerAttributes {
+    player_id: string;
+    roles: RoleType[];
+    first_name: string;
+    last_name: string;
+    country_id: string;
+    country: CountryModel;
+    getCountry: Sequelize.BelongsToGetAssociationMixin<CountryModel>;
+    setCountry: Sequelize.BelongsToSetAssociationMixin<CountryModel, CountryId>;
+    createCountry: Sequelize.BelongsToCreateAssociationMixin<CountryModel>;
+    DraftPick: DraftPickModel;
+    getDraftPick: Sequelize.HasOneGetAssociationMixin<DraftPickModel>;
+    setDraftPick: Sequelize.HasOneSetAssociationMixin<DraftPickModel, DraftPickId>;
+    createDraftPick: Sequelize.HasOneCreateAssociationMixin<DraftPickModel>;
+    StatsMatchSets: MatchSetModel[];
+    getStatsMatchSets: Sequelize.BelongsToManyGetAssociationsMixin<MatchSetModel>;
+    setStatsMatchSets: Sequelize.BelongsToManySetAssociationsMixin<MatchSetModel, MatchSetId>;
+    addStatsMatchSet: Sequelize.BelongsToManyAddAssociationMixin<MatchSetModel, MatchSetId>;
+    addStatsMatchSets: Sequelize.BelongsToManyAddAssociationsMixin<MatchSetModel, MatchSetId>;
+    createStatsMatchSet: Sequelize.BelongsToManyCreateAssociationMixin<MatchSetModel>;
+    removeStatsMatchSet: Sequelize.BelongsToManyRemoveAssociationMixin<MatchSetModel, MatchSetId>;
+    removeStatsMatchSets: Sequelize.BelongsToManyRemoveAssociationsMixin<MatchSetModel, MatchSetId>;
+    hasStatsMatchSet: Sequelize.BelongsToManyHasAssociationMixin<MatchSetModel, MatchSetId>;
+    hasStatsMatchSets: Sequelize.BelongsToManyHasAssociationsMixin<MatchSetModel, MatchSetId>;
+    countStatsMatchSets: Sequelize.BelongsToManyCountAssociationsMixin;
+    SetPositionSets: MatchSetModel[];
+    getSetPositionSets: Sequelize.BelongsToManyGetAssociationsMixin<MatchSetModel>;
+    setSetPositionSets: Sequelize.BelongsToManySetAssociationsMixin<MatchSetModel, MatchSetId>;
+    addSetPositionSet: Sequelize.BelongsToManyAddAssociationMixin<MatchSetModel, MatchSetId>;
+    addSetPositionSets: Sequelize.BelongsToManyAddAssociationsMixin<MatchSetModel, MatchSetId>;
+    createSetPositionSet: Sequelize.BelongsToManyCreateAssociationMixin<MatchSetModel>;
+    removeSetPositionSet: Sequelize.BelongsToManyRemoveAssociationMixin<MatchSetModel, MatchSetId>;
+    removeSetPositionSets: Sequelize.BelongsToManyRemoveAssociationsMixin<MatchSetModel, MatchSetId>;
+    hasSetPositionSet: Sequelize.BelongsToManyHasAssociationMixin<MatchSetModel, MatchSetId>;
+    hasSetPositionSets: Sequelize.BelongsToManyHasAssociationsMixin<MatchSetModel, MatchSetId>;
+    countSetPositionSets: Sequelize.BelongsToManyCountAssociationsMixin;
+    MatchSetStats: MatchSetStatsModel[];
+    getMatchSetStats: Sequelize.HasManyGetAssociationsMixin<MatchSetStatsModel>;
+    setMatchSetStats: Sequelize.HasManySetAssociationsMixin<MatchSetStatsModel, MatchSetStatsId>;
+    addMatchSetStat: Sequelize.HasManyAddAssociationMixin<MatchSetStatsModel, MatchSetStatsId>;
+    addMatchSetStats: Sequelize.HasManyAddAssociationsMixin<MatchSetStatsModel, MatchSetStatsId>;
+    createMatchSetStat: Sequelize.HasManyCreateAssociationMixin<MatchSetStatsModel>;
+    removeMatchSetStat: Sequelize.HasManyRemoveAssociationMixin<MatchSetStatsModel, MatchSetStatsId>;
+    removeMatchSetStats: Sequelize.HasManyRemoveAssociationsMixin<MatchSetStatsModel, MatchSetStatsId>;
+    hasMatchSetStat: Sequelize.HasManyHasAssociationMixin<MatchSetStatsModel, MatchSetStatsId>;
+    hasMatchSetStats: Sequelize.HasManyHasAssociationsMixin<MatchSetStatsModel, MatchSetStatsId>;
+    countMatchSetStats: Sequelize.HasManyCountAssociationsMixin;
+    PerformanceStat: PerformanceStatsModel;
+    getPerformanceStat: Sequelize.HasOneGetAssociationMixin<PerformanceStatsModel>;
+    setPerformanceStat: Sequelize.HasOneSetAssociationMixin<PerformanceStatsModel, PerformanceStatsId>;
+    createPerformanceStat: Sequelize.HasOneCreateAssociationMixin<PerformanceStatsModel>;
+    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;
+    PlayerTraits: PlayerTraitModel[];
+    getPlayerTraits: Sequelize.HasManyGetAssociationsMixin<PlayerTraitModel>;
+    setPlayerTraits: Sequelize.HasManySetAssociationsMixin<PlayerTraitModel, PlayerTraitId>;
+    addPlayerTrait: Sequelize.HasManyAddAssociationMixin<PlayerTraitModel, PlayerTraitId>;
+    addPlayerTraits: Sequelize.HasManyAddAssociationsMixin<PlayerTraitModel, PlayerTraitId>;
+    createPlayerTrait: Sequelize.HasManyCreateAssociationMixin<PlayerTraitModel>;
+    removePlayerTrait: Sequelize.HasManyRemoveAssociationMixin<PlayerTraitModel, PlayerTraitId>;
+    removePlayerTraits: Sequelize.HasManyRemoveAssociationsMixin<PlayerTraitModel, PlayerTraitId>;
+    hasPlayerTrait: Sequelize.HasManyHasAssociationMixin<PlayerTraitModel, PlayerTraitId>;
+    hasPlayerTraits: Sequelize.HasManyHasAssociationsMixin<PlayerTraitModel, PlayerTraitId>;
+    countPlayerTraits: Sequelize.HasManyCountAssociationsMixin;
+    SetPositions: SetPositionModel[];
+    getSetPositions: Sequelize.HasManyGetAssociationsMixin<SetPositionModel>;
+    setSetPositions: Sequelize.HasManySetAssociationsMixin<SetPositionModel, SetPositionId>;
+    addSetPosition: Sequelize.HasManyAddAssociationMixin<SetPositionModel, SetPositionId>;
+    addSetPositions: Sequelize.HasManyAddAssociationsMixin<SetPositionModel, SetPositionId>;
+    createSetPosition: Sequelize.HasManyCreateAssociationMixin<SetPositionModel>;
+    removeSetPosition: Sequelize.HasManyRemoveAssociationMixin<SetPositionModel, SetPositionId>;
+    removeSetPositions: Sequelize.HasManyRemoveAssociationsMixin<SetPositionModel, SetPositionId>;
+    hasSetPosition: Sequelize.HasManyHasAssociationMixin<SetPositionModel, SetPositionId>;
+    hasSetPositions: Sequelize.HasManyHasAssociationsMixin<SetPositionModel, SetPositionId>;
+    countSetPositions: Sequelize.HasManyCountAssociationsMixin;
+    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;
+    Traits: TraitModel[];
+    getTraits: Sequelize.BelongsToManyGetAssociationsMixin<TraitModel>;
+    setTraits: Sequelize.BelongsToManySetAssociationsMixin<TraitModel, TraitId>;
+    addTrait: Sequelize.BelongsToManyAddAssociationMixin<TraitModel, TraitId>;
+    addTraits: Sequelize.BelongsToManyAddAssociationsMixin<TraitModel, TraitId>;
+    createTrait: Sequelize.BelongsToManyCreateAssociationMixin<TraitModel>;
+    removeTrait: Sequelize.BelongsToManyRemoveAssociationMixin<TraitModel, TraitId>;
+    removeTraits: Sequelize.BelongsToManyRemoveAssociationsMixin<TraitModel, TraitId>;
+    hasTrait: Sequelize.BelongsToManyHasAssociationMixin<TraitModel, TraitId>;
+    hasTraits: Sequelize.BelongsToManyHasAssociationsMixin<TraitModel, TraitId>;
+    countTraits: Sequelize.BelongsToManyCountAssociationsMixin;
+    static initModel(sequelize: Sequelize.Sequelize): typeof PlayerModel;
+}

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

@@ -0,0 +1,42 @@
+import { DataTypes, Model } from 'sequelize';
+export class PlayerModel extends Model {
+    static initModel(sequelize) {
+        return PlayerModel.init({
+            player_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true
+            },
+            roles: {
+                type: DataTypes.ARRAY(DataTypes.ENUM('SETTER', 'LIBERO', 'OUTSIDE_HITTER', 'OPPOSITE_HITTER', 'MIDDLE_BLOCKER', 'DEFENSIVE_SPECIALIST')),
+                allowNull: false
+            },
+            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: 'Player',
+            schema: 'public',
+            timestamps: false,
+            indexes: [{
+                    name: 'Player_pk',
+                    unique: true,
+                    fields: [{ name: 'player_id' }]
+                }]
+        });
+    }
+}

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

@@ -0,0 +1,29 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { MatchSetId, MatchSetModel, TeamId, TeamModel } from '.';
+export interface RallyAttributes {
+    rally_id: string;
+    match_set_id: string;
+    serving_team: string;
+    order: number;
+    events: string;
+}
+export type RallyPk = 'rally_id';
+export type RallyId = RallyModel[RallyPk];
+export type RallyCreationAttributes = RallyAttributes;
+export declare class RallyModel extends Model<RallyAttributes, RallyCreationAttributes> implements RallyAttributes {
+    rally_id: string;
+    match_set_id: string;
+    serving_team: string;
+    order: number;
+    events: string;
+    matchSet: MatchSetModel;
+    getMatchSet: Sequelize.BelongsToGetAssociationMixin<MatchSetModel>;
+    setMatchSet: Sequelize.BelongsToSetAssociationMixin<MatchSetModel, MatchSetId>;
+    createMatchSet: Sequelize.BelongsToCreateAssociationMixin<MatchSetModel>;
+    ServingTeam: TeamModel;
+    getServingTeam: Sequelize.BelongsToGetAssociationMixin<TeamModel>;
+    setServingTeam: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>;
+    createServingTeam: Sequelize.BelongsToCreateAssociationMixin<TeamModel>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof RallyModel;
+}

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

@@ -0,0 +1,46 @@
+import { DataTypes, Model } from 'sequelize';
+export class RallyModel extends Model {
+    static initModel(sequelize) {
+        return RallyModel.init({
+            rally_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true
+            },
+            match_set_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'MatchSet',
+                    key: 'match_set_id'
+                }
+            },
+            serving_team: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'Team',
+                    key: 'team_id'
+                }
+            },
+            order: {
+                type: DataTypes.INTEGER,
+                allowNull: false
+            },
+            events: {
+                type: DataTypes.STRING,
+                allowNull: false
+            }
+        }, {
+            sequelize,
+            tableName: 'Rally',
+            schema: 'public',
+            timestamps: false,
+            indexes: [{
+                    name: 'Rally_pk',
+                    unique: true,
+                    fields: [{ name: 'rally_id' }]
+                }]
+        });
+    }
+}

package/dist/esm/data/models/set-position.d.ts

@@ -0,0 +1,29 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { MatchSetId, MatchSetModel, PlayerId, PlayerModel } from '.';
+export interface SetPositionAttributes {
+    player_id: string;
+    match_set_id: string;
+    side: Side;
+    court_position: CourtPositionType;
+}
+export type CourtPositionType = 'NOT_IN_COURT' | 'LIBERO_ZONE' | 'LEFT_FRONT' | 'MIDDLE_FRONT' | 'RIGHT_FRONT' | 'LEFT_BACK' | 'MIDDLE_BACK' | 'RIGHT_BACK';
+export type Side = 'HOME' | 'AWAY';
+export type SetPositionPk = 'player_id' | 'match_set_id';
+export type SetPositionId = SetPositionModel[SetPositionPk];
+export type SetPositionCreationAttributes = SetPositionAttributes;
+export declare class SetPositionModel extends Model<SetPositionAttributes, SetPositionCreationAttributes> implements SetPositionAttributes {
+    player_id: string;
+    match_set_id: string;
+    side: Side;
+    court_position: CourtPositionType;
+    matchSet: MatchSetModel;
+    getMatchSet: Sequelize.BelongsToGetAssociationMixin<MatchSetModel>;
+    setMatchSet: Sequelize.BelongsToSetAssociationMixin<MatchSetModel, MatchSetId>;
+    createMatchSet: Sequelize.BelongsToCreateAssociationMixin<MatchSetModel>;
+    player: PlayerModel;
+    getPlayer: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
+    setPlayer: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;
+    createPlayer: Sequelize.BelongsToCreateAssociationMixin<PlayerModel>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof SetPositionModel;
+}

package/dist/esm/data/models/set-position.js

@@ -0,0 +1,46 @@
+import { DataTypes, Model } from 'sequelize';
+export class SetPositionModel extends Model {
+    static initModel(sequelize) {
+        return SetPositionModel.init({
+            player_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'Player',
+                    key: 'player_id'
+                }
+            },
+            match_set_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'MatchSet',
+                    key: 'match_set_id'
+                }
+            },
+            side: {
+                type: DataTypes.ENUM('AWAY', 'HOME'),
+                allowNull: false
+            },
+            court_position: {
+                type: DataTypes.ENUM('LEFT_BACK', 'LEFT_FRONT', 'LIBERO_ZONE', 'MIDDLE_BACK', 'MIDDLE_FRONT', 'NOT_IN_COURT', 'RIGHT_BACK', 'RIGHT_FRONT'),
+                allowNull: false
+            }
+        }, {
+            sequelize,
+            tableName: 'SetPosition',
+            schema: 'public',
+            timestamps: false,
+            indexes: [{
+                    name: 'RallyPosition_pk',
+                    unique: true,
+                    fields: [
+                        { name: 'match_set_id' },
+                        { name: 'player_id' }
+                    ]
+                }]
+        });
+    }
+}

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

@@ -0,0 +1,162 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import { CoachAttributes, CoachId, CoachModel, CompetitionChampionId, CompetitionChampionModel, CompetitionId, CompetitionModel, CompetitionTeamsId, CompetitionTeamsModel, CountryId, CountryModel, DraftPickId, DraftPickModel, LeagueAttributes, LeagueId, LeagueModel, MatchId, MatchModel, MatchRatingId, MatchRatingModel, PlayerAttributes, PlayerId, PlayerModel, PlayerTeamId, PlayerTeamModel, RallyId, RallyModel } from '.';
+export interface TeamAttributes {
+    team_id: string;
+    name: string;
+    short_name: string;
+    rating: number;
+    coach_id?: string;
+    league_id?: string;
+    country_id?: string;
+    coach?: CoachAttributes;
+    league?: LeagueAttributes;
+    Players?: PlayerAttributes[];
+}
+export type TeamPk = 'team_id';
+export type TeamId = TeamModel[TeamPk];
+export type TeamOptionalAttributes = 'rating';
+export type TeamCreationAttributes = Optional<TeamAttributes, TeamOptionalAttributes>;
+export declare class TeamModel extends Model<TeamAttributes, TeamCreationAttributes> implements TeamAttributes {
+    team_id: string;
+    coach_id: string;
+    name: string;
+    short_name: string;
+    country_id: string;
+    league_id: string;
+    rating: number;
+    coach: CoachModel;
+    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>;
+    Competitions: CompetitionModel[];
+    getCompetitions: Sequelize.BelongsToManyGetAssociationsMixin<CompetitionModel>;
+    setCompetitions: Sequelize.BelongsToManySetAssociationsMixin<CompetitionModel, CompetitionId>;
+    addCompetition: Sequelize.BelongsToManyAddAssociationMixin<CompetitionModel, CompetitionId>;
+    addCompetitions: Sequelize.BelongsToManyAddAssociationsMixin<CompetitionModel, CompetitionId>;
+    createCompetition: Sequelize.BelongsToManyCreateAssociationMixin<CompetitionModel>;
+    removeCompetition: Sequelize.BelongsToManyRemoveAssociationMixin<CompetitionModel, CompetitionId>;
+    removeCompetitions: Sequelize.BelongsToManyRemoveAssociationsMixin<CompetitionModel, CompetitionId>;
+    hasCompetition: Sequelize.BelongsToManyHasAssociationMixin<CompetitionModel, CompetitionId>;
+    hasCompetitions: Sequelize.BelongsToManyHasAssociationsMixin<CompetitionModel, CompetitionId>;
+    countCompetitions: Sequelize.BelongsToManyCountAssociationsMixin;
+    CompetitionChampions: CompetitionChampionModel[];
+    getCompetitionChampions: Sequelize.HasManyGetAssociationsMixin<CompetitionChampionModel>;
+    setCompetitionChampions: Sequelize.HasManySetAssociationsMixin<CompetitionChampionModel, CompetitionChampionId>;
+    addCompetitionChampion: Sequelize.HasManyAddAssociationMixin<CompetitionChampionModel, CompetitionChampionId>;
+    addCompetitionChampions: Sequelize.HasManyAddAssociationsMixin<CompetitionChampionModel, CompetitionChampionId>;
+    createCompetitionChampion: Sequelize.HasManyCreateAssociationMixin<CompetitionChampionModel>;
+    removeCompetitionChampion: Sequelize.HasManyRemoveAssociationMixin<CompetitionChampionModel, CompetitionChampionId>;
+    removeCompetitionChampions: Sequelize.HasManyRemoveAssociationsMixin<CompetitionChampionModel, CompetitionChampionId>;
+    hasCompetitionChampion: Sequelize.HasManyHasAssociationMixin<CompetitionChampionModel, CompetitionChampionId>;
+    hasCompetitionChampions: Sequelize.HasManyHasAssociationsMixin<CompetitionChampionModel, CompetitionChampionId>;
+    countCompetitionChampions: Sequelize.HasManyCountAssociationsMixin;
+    CompetitionTeams: CompetitionTeamsModel[];
+    getCompetitionTeams: Sequelize.HasManyGetAssociationsMixin<CompetitionTeamsModel>;
+    setCompetitionTeams: Sequelize.HasManySetAssociationsMixin<CompetitionTeamsModel, CompetitionTeamsId>;
+    addCompetitionTeam: Sequelize.HasManyAddAssociationMixin<CompetitionTeamsModel, CompetitionTeamsId>;
+    addCompetitionTeams: Sequelize.HasManyAddAssociationsMixin<CompetitionTeamsModel, CompetitionTeamsId>;
+    createCompetitionTeam: Sequelize.HasManyCreateAssociationMixin<CompetitionTeamsModel>;
+    removeCompetitionTeam: Sequelize.HasManyRemoveAssociationMixin<CompetitionTeamsModel, CompetitionTeamsId>;
+    removeCompetitionTeams: Sequelize.HasManyRemoveAssociationsMixin<CompetitionTeamsModel, CompetitionTeamsId>;
+    hasCompetitionTeam: Sequelize.HasManyHasAssociationMixin<CompetitionTeamsModel, CompetitionTeamsId>;
+    hasCompetitionTeams: Sequelize.HasManyHasAssociationsMixin<CompetitionTeamsModel, CompetitionTeamsId>;
+    countCompetitionTeams: Sequelize.HasManyCountAssociationsMixin;
+    DraftPicks: DraftPickModel[];
+    getDraftPicks: Sequelize.HasManyGetAssociationsMixin<DraftPickModel>;
+    setDraftPicks: Sequelize.HasManySetAssociationsMixin<DraftPickModel, DraftPickId>;
+    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;
+    HomeMatches: MatchModel[];
+    getHomeMatches: Sequelize.HasManyGetAssociationsMixin<MatchModel>;
+    setHomeMatches: Sequelize.HasManySetAssociationsMixin<MatchModel, MatchId>;
+    addHomeMatch: Sequelize.HasManyAddAssociationMixin<MatchModel, MatchId>;
+    addHomeMatches: Sequelize.HasManyAddAssociationsMixin<MatchModel, MatchId>;
+    createHomeMatch: Sequelize.HasManyCreateAssociationMixin<MatchModel>;
+    removeHomeMatch: Sequelize.HasManyRemoveAssociationMixin<MatchModel, MatchId>;
+    removeHomeMatches: Sequelize.HasManyRemoveAssociationsMixin<MatchModel, MatchId>;
+    hasHomeMatch: Sequelize.HasManyHasAssociationMixin<MatchModel, MatchId>;
+    hasHomeMatches: Sequelize.HasManyHasAssociationsMixin<MatchModel, MatchId>;
+    countHomeMatches: Sequelize.HasManyCountAssociationsMixin;
+    AwayMatches: MatchModel[];
+    getAwayMatches: Sequelize.HasManyGetAssociationsMixin<MatchModel>;
+    setAwayMatches: Sequelize.HasManySetAssociationsMixin<MatchModel, MatchId>;
+    addAwayMatch: Sequelize.HasManyAddAssociationMixin<MatchModel, MatchId>;
+    addAwayMatches: Sequelize.HasManyAddAssociationsMixin<MatchModel, MatchId>;
+    createAwayMatch: Sequelize.HasManyCreateAssociationMixin<MatchModel>;
+    removeAwayMatch: Sequelize.HasManyRemoveAssociationMixin<MatchModel, MatchId>;
+    removeAwayMatches: Sequelize.HasManyRemoveAssociationsMixin<MatchModel, MatchId>;
+    hasAwayMatch: Sequelize.HasManyHasAssociationMixin<MatchModel, MatchId>;
+    hasAwayMatches: Sequelize.HasManyHasAssociationsMixin<MatchModel, MatchId>;
+    countAwayMatches: Sequelize.HasManyCountAssociationsMixin;
+    RatingMatches: MatchModel[];
+    getRatingMatches: Sequelize.BelongsToManyGetAssociationsMixin<MatchModel>;
+    setRatingMatches: Sequelize.BelongsToManySetAssociationsMixin<MatchModel, MatchId>;
+    addRatingMatch: Sequelize.BelongsToManyAddAssociationMixin<MatchModel, MatchId>;
+    addRatingMatches: Sequelize.BelongsToManyAddAssociationsMixin<MatchModel, MatchId>;
+    createRatingMatch: Sequelize.BelongsToManyCreateAssociationMixin<MatchModel>;
+    removeRatingMatch: Sequelize.BelongsToManyRemoveAssociationMixin<MatchModel, MatchId>;
+    removeRatingMatches: Sequelize.BelongsToManyRemoveAssociationsMixin<MatchModel, MatchId>;
+    hasRatingMatch: Sequelize.BelongsToManyHasAssociationMixin<MatchModel, MatchId>;
+    hasRatingMatches: Sequelize.BelongsToManyHasAssociationsMixin<MatchModel, MatchId>;
+    countRatingMatches: Sequelize.BelongsToManyCountAssociationsMixin;
+    MatchRatings: MatchRatingModel[];
+    getMatchRatings: Sequelize.HasManyGetAssociationsMixin<MatchRatingModel>;
+    setMatchRatings: Sequelize.HasManySetAssociationsMixin<MatchRatingModel, MatchRatingId>;
+    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;
+    Players: PlayerModel[];
+    getPlayers: Sequelize.BelongsToManyGetAssociationsMixin<PlayerModel>;
+    setPlayers: Sequelize.BelongsToManySetAssociationsMixin<PlayerModel, PlayerId>;
+    addPlayer: Sequelize.BelongsToManyAddAssociationMixin<PlayerModel, PlayerId>;
+    addPlayers: Sequelize.BelongsToManyAddAssociationsMixin<PlayerModel, PlayerId>;
+    createPlayer: Sequelize.BelongsToManyCreateAssociationMixin<PlayerModel>;
+    removePlayer: Sequelize.BelongsToManyRemoveAssociationMixin<PlayerModel, PlayerId>;
+    removePlayers: Sequelize.BelongsToManyRemoveAssociationsMixin<PlayerModel, PlayerId>;
+    hasPlayer: Sequelize.BelongsToManyHasAssociationMixin<PlayerModel, PlayerId>;
+    hasPlayers: Sequelize.BelongsToManyHasAssociationsMixin<PlayerModel, PlayerId>;
+    countPlayers: Sequelize.BelongsToManyCountAssociationsMixin;
+    PlayerTeams: PlayerTeamModel[];
+    getPlayerTeams: Sequelize.HasManyGetAssociationsMixin<PlayerTeamModel>;
+    setPlayerTeams: Sequelize.HasManySetAssociationsMixin<PlayerTeamModel, PlayerTeamId>;
+    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;
+    static initModel(sequelize: Sequelize.Sequelize): typeof TeamModel;
+}

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

@@ -0,0 +1,59 @@
+import { DataTypes, Model } from 'sequelize';
+export class TeamModel extends Model {
+    static initModel(sequelize) {
+        return TeamModel.init({
+            team_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true
+            },
+            coach_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'Coach',
+                    key: 'coach_id'
+                }
+            },
+            name: {
+                type: DataTypes.STRING,
+                allowNull: false
+            },
+            short_name: {
+                type: DataTypes.STRING,
+                allowNull: false
+            },
+            country_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'Country',
+                    key: 'country_id'
+                }
+            },
+            league_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'League',
+                    key: 'league_id'
+                }
+            },
+            rating: {
+                type: DataTypes.REAL,
+                allowNull: false,
+                defaultValue: 1000.0
+            }
+        }, {
+            sequelize,
+            tableName: 'Team',
+            schema: 'public',
+            timestamps: false,
+            indexes: [{
+                    name: 'Team_pk',
+                    unique: true,
+                    fields: [{ name: 'team_id' }]
+                }]
+        });
+    }
+}

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

@@ -0,0 +1,37 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { PlayerId, PlayerModel, PlayerTraitId, PlayerTraitModel } from '.';
+export interface TraitAttributes {
+    trait_id: string;
+    name: string;
+}
+export type TraitPk = 'trait_id';
+export type TraitId = TraitModel[TraitPk];
+export type TraitCreationAttributes = TraitAttributes;
+export declare class TraitModel extends Model<TraitAttributes, TraitCreationAttributes> implements TraitAttributes {
+    trait_id: string;
+    name: string;
+    Players: PlayerModel[];
+    getPlayers: Sequelize.BelongsToManyGetAssociationsMixin<PlayerModel>;
+    setPlayers: Sequelize.BelongsToManySetAssociationsMixin<PlayerModel, PlayerId>;
+    addPlayer: Sequelize.BelongsToManyAddAssociationMixin<PlayerModel, PlayerId>;
+    addPlayers: Sequelize.BelongsToManyAddAssociationsMixin<PlayerModel, PlayerId>;
+    createPlayer: Sequelize.BelongsToManyCreateAssociationMixin<PlayerModel>;
+    removePlayer: Sequelize.BelongsToManyRemoveAssociationMixin<PlayerModel, PlayerId>;
+    removePlayers: Sequelize.BelongsToManyRemoveAssociationsMixin<PlayerModel, PlayerId>;
+    hasPlayer: Sequelize.BelongsToManyHasAssociationMixin<PlayerModel, PlayerId>;
+    hasPlayers: Sequelize.BelongsToManyHasAssociationsMixin<PlayerModel, PlayerId>;
+    countPlayers: Sequelize.BelongsToManyCountAssociationsMixin;
+    PlayerTraits: PlayerTraitModel[];
+    getPlayerTraits: Sequelize.HasManyGetAssociationsMixin<PlayerTraitModel>;
+    setPlayerTraits: Sequelize.HasManySetAssociationsMixin<PlayerTraitModel, PlayerTraitId>;
+    addPlayerTrait: Sequelize.HasManyAddAssociationMixin<PlayerTraitModel, PlayerTraitId>;
+    addPlayerTraits: Sequelize.HasManyAddAssociationsMixin<PlayerTraitModel, PlayerTraitId>;
+    createPlayerTrait: Sequelize.HasManyCreateAssociationMixin<PlayerTraitModel>;
+    removePlayerTrait: Sequelize.HasManyRemoveAssociationMixin<PlayerTraitModel, PlayerTraitId>;
+    removePlayerTraits: Sequelize.HasManyRemoveAssociationsMixin<PlayerTraitModel, PlayerTraitId>;
+    hasPlayerTrait: Sequelize.HasManyHasAssociationMixin<PlayerTraitModel, PlayerTraitId>;
+    hasPlayerTraits: Sequelize.HasManyHasAssociationsMixin<PlayerTraitModel, PlayerTraitId>;
+    countPlayerTraits: Sequelize.HasManyCountAssociationsMixin;
+    static initModel(sequelize: Sequelize.Sequelize): typeof TraitModel;
+}

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

@@ -0,0 +1,26 @@
+import { DataTypes, Model } from 'sequelize';
+export class TraitModel extends Model {
+    static initModel(sequelize) {
+        return TraitModel.init({
+            trait_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true
+            },
+            name: {
+                type: DataTypes.STRING,
+                allowNull: false
+            }
+        }, {
+            sequelize,
+            tableName: 'Trait',
+            schema: 'public',
+            timestamps: false,
+            indexes: [{
+                    name: 'trait_pk',
+                    unique: true,
+                    fields: [{ name: 'trait_id' }]
+                }]
+        });
+    }
+}

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

@@ -0,0 +1,22 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+export interface UserAttributes {
+    user_id: string;
+    username: string;
+    email: string;
+    password: string;
+    role: UserRole;
+}
+export type UserPk = 'user_id';
+export type UserId = UserModel[UserPk];
+export type UserRole = 'ADMIN' | 'PLAYER';
+export type UserOptionalAttributes = 'role';
+export type UserCreationAttributes = Optional<UserAttributes, UserOptionalAttributes>;
+export declare class UserModel extends Model<UserAttributes, UserCreationAttributes> implements UserAttributes {
+    user_id: string;
+    username: string;
+    email: string;
+    password: string;
+    role: UserRole;
+    static initModel(sequelize: Sequelize.Sequelize): typeof UserModel;
+}