volleyballsimtypes 0.0.1

package/src/data/models/rally.ts

@@ -0,0 +1,229 @@
+import * as Sequelize from 'sequelize'
+import { DataTypes, Model } from 'sequelize'
+import type { BlockAttributes, BlockId, BlockModel } from './block'
+import type { EventId, EventModel } from './event'
+import type { LiberoReplacementAttributes, LiberoReplacementId, LiberoReplacementModel } from './libero-replacement'
+import type { MatchSetId, MatchSetModel } from './match-set'
+import type { PlayerId, PlayerModel } from './player'
+import type { RallyPositionAttributes, RallyPositionId, RallyPositionModel } from './rally-position'
+import type { ReceptionAttributes, ReceptionId, ReceptionModel } from './reception'
+import type { ScoreAttributes, ScoreId, ScoreModel } from './score'
+import type { ServeAttributes, ServeId, ServeModel } from './serve'
+import type { SetAttributes, SetId, SetModel } from './set'
+import type { SpikeAttributes, SpikeId, SpikeModel } from './spike'
+import type { SubstitutionAttributes, SubstitutionId, SubstitutionModel } from './substitution'
+import type { TeamId, TeamModel } from './team'
+
+export interface RallyAttributes {
+  rally_id: string
+  match_set_id: string
+  serving_team: string
+  order: number
+  RallyPositions?: RallyPositionAttributes[]
+  Serves?: ServeAttributes[]
+  Receptions?: ReceptionAttributes[]
+  Sets?: SetAttributes[]
+  Spikes?: SpikeAttributes[]
+  Blocks?: BlockAttributes[]
+  Substitutions?: SubstitutionAttributes[]
+  LiberoReplacements?: LiberoReplacementAttributes[]
+  Scores?: ScoreAttributes[]
+}
+
+export type RallyPk = 'rally_id'
+export type RallyId = RallyModel[RallyPk]
+export type RallyCreationAttributes = RallyAttributes
+
+export class RallyModel extends Model<RallyAttributes, RallyCreationAttributes> implements RallyAttributes {
+  rally_id!: string
+  match_set_id!: string
+  serving_team!: string
+  order!: number
+
+  // Rally belongsTo MatchSet via match_set_id
+  match_set!: MatchSetModel
+  getMatch_set!: Sequelize.BelongsToGetAssociationMixin<MatchSetModel>
+  setMatch_set!: Sequelize.BelongsToSetAssociationMixin<MatchSetModel, MatchSetId>
+  createMatch_set!: Sequelize.BelongsToCreateAssociationMixin<MatchSetModel>
+  // Rally hasMany Block via rally_id
+  Blocks!: BlockModel[]
+  getBlocks!: Sequelize.HasManyGetAssociationsMixin<BlockModel>
+  setBlocks!: Sequelize.HasManySetAssociationsMixin<BlockModel, BlockId>
+  addBlock!: Sequelize.HasManyAddAssociationMixin<BlockModel, BlockId>
+  addBlocks!: Sequelize.HasManyAddAssociationsMixin<BlockModel, BlockId>
+  createBlock!: Sequelize.HasManyCreateAssociationMixin<BlockModel>
+  removeBlock!: Sequelize.HasManyRemoveAssociationMixin<BlockModel, BlockId>
+  removeBlocks!: Sequelize.HasManyRemoveAssociationsMixin<BlockModel, BlockId>
+  hasBlock!: Sequelize.HasManyHasAssociationMixin<BlockModel, BlockId>
+  hasBlocks!: Sequelize.HasManyHasAssociationsMixin<BlockModel, BlockId>
+  countBlocks!: Sequelize.HasManyCountAssociationsMixin
+  // Rally hasMany Event via rally_id
+  Events!: EventModel[]
+  getEvents!: Sequelize.HasManyGetAssociationsMixin<EventModel>
+  setEvents!: Sequelize.HasManySetAssociationsMixin<EventModel, EventId>
+  addEvent!: Sequelize.HasManyAddAssociationMixin<EventModel, EventId>
+  addEvents!: Sequelize.HasManyAddAssociationsMixin<EventModel, EventId>
+  createEvent!: Sequelize.HasManyCreateAssociationMixin<EventModel>
+  removeEvent!: Sequelize.HasManyRemoveAssociationMixin<EventModel, EventId>
+  removeEvents!: Sequelize.HasManyRemoveAssociationsMixin<EventModel, EventId>
+  hasEvent!: Sequelize.HasManyHasAssociationMixin<EventModel, EventId>
+  hasEvents!: Sequelize.HasManyHasAssociationsMixin<EventModel, EventId>
+  countEvents!: Sequelize.HasManyCountAssociationsMixin
+  // Rally hasMany LiberoReplacement via rally_id
+  LiberoReplacements!: LiberoReplacementModel[]
+  getLiberoReplacements!: Sequelize.HasManyGetAssociationsMixin<LiberoReplacementModel>
+  setLiberoReplacements!: Sequelize.HasManySetAssociationsMixin<LiberoReplacementModel, LiberoReplacementId>
+  addLiberoReplacement!: Sequelize.HasManyAddAssociationMixin<LiberoReplacementModel, LiberoReplacementId>
+  addLiberoReplacements!: Sequelize.HasManyAddAssociationsMixin<LiberoReplacementModel, LiberoReplacementId>
+  createLiberoReplacement!: Sequelize.HasManyCreateAssociationMixin<LiberoReplacementModel>
+  removeLiberoReplacement!: Sequelize.HasManyRemoveAssociationMixin<LiberoReplacementModel, LiberoReplacementId>
+  removeLiberoReplacements!: Sequelize.HasManyRemoveAssociationsMixin<LiberoReplacementModel, LiberoReplacementId>
+  hasLiberoReplacement!: Sequelize.HasManyHasAssociationMixin<LiberoReplacementModel, LiberoReplacementId>
+  hasLiberoReplacements!: Sequelize.HasManyHasAssociationsMixin<LiberoReplacementModel, LiberoReplacementId>
+  countLiberoReplacements!: Sequelize.HasManyCountAssociationsMixin
+  // Rally belongsToMany Player via rally_id and player_id
+  player_id_Player_RallyPositions!: PlayerModel[]
+  getPlayer_id_Player_RallyPositions!: Sequelize.BelongsToManyGetAssociationsMixin<PlayerModel>
+  setPlayer_id_Player_RallyPositions!: Sequelize.BelongsToManySetAssociationsMixin<PlayerModel, PlayerId>
+  addPlayer_id_Player_RallyPosition!: Sequelize.BelongsToManyAddAssociationMixin<PlayerModel, PlayerId>
+  addPlayer_id_Player_RallyPositions!: Sequelize.BelongsToManyAddAssociationsMixin<PlayerModel, PlayerId>
+  createPlayer_id_Player_RallyPosition!: Sequelize.BelongsToManyCreateAssociationMixin<PlayerModel>
+  removePlayer_id_Player_RallyPosition!: Sequelize.BelongsToManyRemoveAssociationMixin<PlayerModel, PlayerId>
+  removePlayer_id_Player_RallyPositions!: Sequelize.BelongsToManyRemoveAssociationsMixin<PlayerModel, PlayerId>
+  hasPlayer_id_Player_RallyPosition!: Sequelize.BelongsToManyHasAssociationMixin<PlayerModel, PlayerId>
+  hasPlayer_id_Player_RallyPositions!: Sequelize.BelongsToManyHasAssociationsMixin<PlayerModel, PlayerId>
+  countPlayer_id_Player_RallyPositions!: Sequelize.BelongsToManyCountAssociationsMixin
+  // Rally hasMany RallyPosition via rally_id
+  RallyPositions!: RallyPositionModel[]
+  getRallyPositions!: Sequelize.HasManyGetAssociationsMixin<RallyPositionModel>
+  setRallyPositions!: Sequelize.HasManySetAssociationsMixin<RallyPositionModel, RallyPositionId>
+  addRallyPosition!: Sequelize.HasManyAddAssociationMixin<RallyPositionModel, RallyPositionId>
+  addRallyPositions!: Sequelize.HasManyAddAssociationsMixin<RallyPositionModel, RallyPositionId>
+  createRallyPosition!: Sequelize.HasManyCreateAssociationMixin<RallyPositionModel>
+  removeRallyPosition!: Sequelize.HasManyRemoveAssociationMixin<RallyPositionModel, RallyPositionId>
+  removeRallyPositions!: Sequelize.HasManyRemoveAssociationsMixin<RallyPositionModel, RallyPositionId>
+  hasRallyPosition!: Sequelize.HasManyHasAssociationMixin<RallyPositionModel, RallyPositionId>
+  hasRallyPositions!: Sequelize.HasManyHasAssociationsMixin<RallyPositionModel, RallyPositionId>
+  countRallyPositions!: Sequelize.HasManyCountAssociationsMixin
+  // Rally hasMany Reception via rally_id
+  Receptions!: ReceptionModel[]
+  getReceptions!: Sequelize.HasManyGetAssociationsMixin<ReceptionModel>
+  setReceptions!: Sequelize.HasManySetAssociationsMixin<ReceptionModel, ReceptionId>
+  addReception!: Sequelize.HasManyAddAssociationMixin<ReceptionModel, ReceptionId>
+  addReceptions!: Sequelize.HasManyAddAssociationsMixin<ReceptionModel, ReceptionId>
+  createReception!: Sequelize.HasManyCreateAssociationMixin<ReceptionModel>
+  removeReception!: Sequelize.HasManyRemoveAssociationMixin<ReceptionModel, ReceptionId>
+  removeReceptions!: Sequelize.HasManyRemoveAssociationsMixin<ReceptionModel, ReceptionId>
+  hasReception!: Sequelize.HasManyHasAssociationMixin<ReceptionModel, ReceptionId>
+  hasReceptions!: Sequelize.HasManyHasAssociationsMixin<ReceptionModel, ReceptionId>
+  countReceptions!: Sequelize.HasManyCountAssociationsMixin
+  // Rally hasMany Score via rally_id
+  Scores!: ScoreModel[]
+  getScores!: Sequelize.HasManyGetAssociationsMixin<ScoreModel>
+  setScores!: Sequelize.HasManySetAssociationsMixin<ScoreModel, ScoreId>
+  addScore!: Sequelize.HasManyAddAssociationMixin<ScoreModel, ScoreId>
+  addScores!: Sequelize.HasManyAddAssociationsMixin<ScoreModel, ScoreId>
+  createScore!: Sequelize.HasManyCreateAssociationMixin<ScoreModel>
+  removeScore!: Sequelize.HasManyRemoveAssociationMixin<ScoreModel, ScoreId>
+  removeScores!: Sequelize.HasManyRemoveAssociationsMixin<ScoreModel, ScoreId>
+  hasScore!: Sequelize.HasManyHasAssociationMixin<ScoreModel, ScoreId>
+  hasScores!: Sequelize.HasManyHasAssociationsMixin<ScoreModel, ScoreId>
+  countScores!: Sequelize.HasManyCountAssociationsMixin
+  // Rally hasMany Serve via rally_id
+  Serves!: ServeModel[]
+  getServes!: Sequelize.HasManyGetAssociationsMixin<ServeModel>
+  setServes!: Sequelize.HasManySetAssociationsMixin<ServeModel, ServeId>
+  addSerf!: Sequelize.HasManyAddAssociationMixin<ServeModel, ServeId>
+  addServes!: Sequelize.HasManyAddAssociationsMixin<ServeModel, ServeId>
+  createSerf!: Sequelize.HasManyCreateAssociationMixin<ServeModel>
+  removeSerf!: Sequelize.HasManyRemoveAssociationMixin<ServeModel, ServeId>
+  removeServes!: Sequelize.HasManyRemoveAssociationsMixin<ServeModel, ServeId>
+  hasSerf!: Sequelize.HasManyHasAssociationMixin<ServeModel, ServeId>
+  hasServes!: Sequelize.HasManyHasAssociationsMixin<ServeModel, ServeId>
+  countServes!: Sequelize.HasManyCountAssociationsMixin
+  // Rally hasMany Set via rally_id
+  Sets!: SetModel[]
+  getSets!: Sequelize.HasManyGetAssociationsMixin<SetModel>
+  setSets!: Sequelize.HasManySetAssociationsMixin<SetModel, SetId>
+  addSet!: Sequelize.HasManyAddAssociationMixin<SetModel, SetId>
+  addSets!: Sequelize.HasManyAddAssociationsMixin<SetModel, SetId>
+  createSet!: Sequelize.HasManyCreateAssociationMixin<SetModel>
+  removeSet!: Sequelize.HasManyRemoveAssociationMixin<SetModel, SetId>
+  removeSets!: Sequelize.HasManyRemoveAssociationsMixin<SetModel, SetId>
+  hasSet!: Sequelize.HasManyHasAssociationMixin<SetModel, SetId>
+  hasSets!: Sequelize.HasManyHasAssociationsMixin<SetModel, SetId>
+  countSets!: Sequelize.HasManyCountAssociationsMixin
+  // Rally hasMany Spike via rally_id
+  Spikes!: SpikeModel[]
+  getSpikes!: Sequelize.HasManyGetAssociationsMixin<SpikeModel>
+  setSpikes!: Sequelize.HasManySetAssociationsMixin<SpikeModel, SpikeId>
+  addSpike!: Sequelize.HasManyAddAssociationMixin<SpikeModel, SpikeId>
+  addSpikes!: Sequelize.HasManyAddAssociationsMixin<SpikeModel, SpikeId>
+  createSpike!: Sequelize.HasManyCreateAssociationMixin<SpikeModel>
+  removeSpike!: Sequelize.HasManyRemoveAssociationMixin<SpikeModel, SpikeId>
+  removeSpikes!: Sequelize.HasManyRemoveAssociationsMixin<SpikeModel, SpikeId>
+  hasSpike!: Sequelize.HasManyHasAssociationMixin<SpikeModel, SpikeId>
+  hasSpikes!: Sequelize.HasManyHasAssociationsMixin<SpikeModel, SpikeId>
+  countSpikes!: Sequelize.HasManyCountAssociationsMixin
+  // Rally hasMany Substitution via rally_id
+  Substitutions!: SubstitutionModel[]
+  getSubstitutions!: Sequelize.HasManyGetAssociationsMixin<SubstitutionModel>
+  setSubstitutions!: Sequelize.HasManySetAssociationsMixin<SubstitutionModel, SubstitutionId>
+  addSubstitution!: Sequelize.HasManyAddAssociationMixin<SubstitutionModel, SubstitutionId>
+  addSubstitutions!: Sequelize.HasManyAddAssociationsMixin<SubstitutionModel, SubstitutionId>
+  createSubstitution!: Sequelize.HasManyCreateAssociationMixin<SubstitutionModel>
+  removeSubstitution!: Sequelize.HasManyRemoveAssociationMixin<SubstitutionModel, SubstitutionId>
+  removeSubstitutions!: Sequelize.HasManyRemoveAssociationsMixin<SubstitutionModel, SubstitutionId>
+  hasSubstitution!: Sequelize.HasManyHasAssociationMixin<SubstitutionModel, SubstitutionId>
+  hasSubstitutions!: Sequelize.HasManyHasAssociationsMixin<SubstitutionModel, SubstitutionId>
+  countSubstitutions!: Sequelize.HasManyCountAssociationsMixin
+  // Rally belongsTo Team via serving_team
+  serving_team_Team!: TeamModel
+  getServing_team_Team!: Sequelize.BelongsToGetAssociationMixin<TeamModel>
+  setServing_team_Team!: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>
+  createServing_team_Team!: Sequelize.BelongsToCreateAssociationMixin<TeamModel>
+
+  static initModel (sequelize: Sequelize.Sequelize): typeof RallyModel {
+    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
+      }
+    }, {
+      sequelize,
+      tableName: 'Rally',
+      schema: 'public',
+      timestamps: false,
+      indexes: [
+        {
+          name: 'Rally_pk',
+          unique: true,
+          fields: [
+            { name: 'rally_id' }
+          ]
+        }
+      ]
+    })
+  }
+}

package/src/data/models/reception.ts

@@ -0,0 +1,113 @@
+import * as Sequelize from 'sequelize'
+import { DataTypes, Model } from 'sequelize'
+import type { PlayerId, PlayerModel } from './player'
+import type { RallyId, RallyModel } from './rally'
+
+export interface ReceptionAttributes {
+  event_id: string
+  rally_id: string
+  event_type: 'LIBERO_REPLACEMENT' | 'SUBSTITUTION' | 'SERVE' | 'RECEPTION' | 'SET' | 'SPIKE' | 'BLOCK' | 'SCORE'
+  failure: 'NO_FAILURE' | 'FAULT' | 'MISS' | 'OUT_OF_BOUNDS' | 'BAD_PASS'
+  type: 'DIG' | 'OVERHAND' | 'ONE_HAND' | 'OTHER_BODY_PART'
+  target: 'NO_TARGET' | 'OPPONENT_RIGHT_BACK' | 'OPPONENT_MIDDLE_BACK' | 'OPPONENT_LEFT_BACK' | 'OPPONENT_RIGHT_FRONT' | 'OPPONENT_MIDDLE_FRONT' | 'OPPONENT_LEFT_FRONT' | 'TEAM_LEFT_FRONT' | 'TEAM_MIDDLE_FRONT' | 'TEAM_RIGHT_FRONT' | 'TEAM_LEFT_BACK' | 'TEAM_MIDDLE_BACK' | 'TEAM_RIGHT_BACK'
+  order: number
+  player_id: string
+  modifier: number
+  score: number
+}
+
+export type ReceptionPk = 'event_id'
+export type ReceptionId = ReceptionModel[ReceptionPk]
+export type ReceptionCreationAttributes = ReceptionAttributes
+
+export class ReceptionModel extends Model<ReceptionAttributes, ReceptionCreationAttributes> implements ReceptionAttributes {
+  event_id!: string
+  rally_id!: string
+  event_type!: 'LIBERO_REPLACEMENT' | 'SUBSTITUTION' | 'SERVE' | 'RECEPTION' | 'SET' | 'SPIKE' | 'BLOCK' | 'SCORE'
+  failure!: 'NO_FAILURE' | 'FAULT' | 'MISS' | 'OUT_OF_BOUNDS' | 'BAD_PASS'
+  type!: 'DIG' | 'OVERHAND' | 'ONE_HAND' | 'OTHER_BODY_PART'
+  target!: 'NO_TARGET' | 'OPPONENT_RIGHT_BACK' | 'OPPONENT_MIDDLE_BACK' | 'OPPONENT_LEFT_BACK' | 'OPPONENT_RIGHT_FRONT' | 'OPPONENT_MIDDLE_FRONT' | 'OPPONENT_LEFT_FRONT' | 'TEAM_LEFT_FRONT' | 'TEAM_MIDDLE_FRONT' | 'TEAM_RIGHT_FRONT' | 'TEAM_LEFT_BACK' | 'TEAM_MIDDLE_BACK' | 'TEAM_RIGHT_BACK'
+  order!: number
+  player_id!: string
+  modifier!: number
+  score!: number
+
+  // Reception belongsTo Player via player_id
+  player!: PlayerModel
+  getPlayer!: Sequelize.BelongsToGetAssociationMixin<PlayerModel>
+  setPlayer!: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>
+  createPlayer!: Sequelize.BelongsToCreateAssociationMixin<PlayerModel>
+  // Reception belongsTo Rally via rally_id
+  rally!: RallyModel
+  getRally!: Sequelize.BelongsToGetAssociationMixin<RallyModel>
+  setRally!: Sequelize.BelongsToSetAssociationMixin<RallyModel, RallyId>
+  createRally!: Sequelize.BelongsToCreateAssociationMixin<RallyModel>
+
+  static initModel (sequelize: Sequelize.Sequelize): typeof ReceptionModel {
+    return ReceptionModel.init({
+      event_id: {
+        type: DataTypes.UUID,
+        allowNull: false,
+        primaryKey: true
+      },
+      rally_id: {
+        type: DataTypes.UUID,
+        allowNull: false,
+        references: {
+          model: 'Rally',
+          key: 'rally_id'
+        }
+      },
+      event_type: {
+        type: DataTypes.ENUM('LIBERO_REPLACEMENT', 'SUBSTITUTION', 'SERVE', 'RECEPTION', 'SET', 'SPIKE', 'BLOCK', 'SCORE'),
+        allowNull: false
+      },
+      failure: {
+        type: DataTypes.ENUM('NO_FAILURE', 'FAULT', 'MISS', 'OUT_OF_BOUNDS', 'BAD_PASS'),
+        allowNull: false
+      },
+      type: {
+        type: DataTypes.ENUM('DIG', 'OVERHAND', 'ONE_HAND', 'OTHER_BODY_PART'),
+        allowNull: false
+      },
+      target: {
+        type: DataTypes.ENUM('NO_TARGET', 'OPPONENT_RIGHT_BACK', 'OPPONENT_MIDDLE_BACK', 'OPPONENT_LEFT_BACK', 'OPPONENT_RIGHT_FRONT', 'OPPONENT_MIDDLE_FRONT', 'OPPONENT_LEFT_FRONT', 'TEAM_LEFT_FRONT', 'TEAM_MIDDLE_FRONT', 'TEAM_RIGHT_FRONT', 'TEAM_LEFT_BACK', 'TEAM_MIDDLE_BACK', 'TEAM_RIGHT_BACK'),
+        allowNull: false
+      },
+      order: {
+        type: DataTypes.INTEGER,
+        allowNull: false
+      },
+      player_id: {
+        type: DataTypes.UUID,
+        allowNull: false,
+        references: {
+          model: 'Player',
+          key: 'player_id'
+        }
+      },
+      modifier: {
+        type: DataTypes.REAL,
+        allowNull: false
+      },
+      score: {
+        type: DataTypes.REAL,
+        allowNull: false
+      }
+    }, {
+      sequelize,
+      tableName: 'Reception',
+      schema: 'public',
+      timestamps: false,
+      indexes: [
+        {
+          name: 'Reception_pk',
+          unique: true,
+          fields: [
+            { name: 'event_id' }
+          ]
+        }
+      ]
+    })
+  }
+}

package/src/data/models/score.ts

@@ -0,0 +1,99 @@
+import * as Sequelize from 'sequelize'
+import { DataTypes, Model } from 'sequelize'
+import type { PlayerId, PlayerModel } from './player'
+import type { RallyId, RallyModel } from './rally'
+import type { TeamId, TeamModel } from './team'
+
+export interface ScoreAttributes {
+  event_id: string
+  rally_id: string
+  event_type: 'LIBERO_REPLACEMENT' | 'SUBSTITUTION' | 'SERVE' | 'RECEPTION' | 'SET' | 'SPIKE' | 'BLOCK' | 'SCORE'
+  team_id: string
+  order: number
+  player_id: string
+}
+
+export type ScorePk = 'event_id'
+export type ScoreId = ScoreModel[ScorePk]
+export type ScoreCreationAttributes = ScoreAttributes
+
+export class ScoreModel extends Model<ScoreAttributes, ScoreCreationAttributes> implements ScoreAttributes {
+  event_id!: string
+  rally_id!: string
+  event_type!: 'LIBERO_REPLACEMENT' | 'SUBSTITUTION' | 'SERVE' | 'RECEPTION' | 'SET' | 'SPIKE' | 'BLOCK' | 'SCORE'
+  team_id!: string
+  order!: number
+  player_id!: string
+
+  // Score belongsTo Player via player_id
+  player!: PlayerModel
+  getPlayer!: Sequelize.BelongsToGetAssociationMixin<PlayerModel>
+  setPlayer!: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>
+  createPlayer!: Sequelize.BelongsToCreateAssociationMixin<PlayerModel>
+  // Score belongsTo Rally via rally_id
+  rally!: RallyModel
+  getRally!: Sequelize.BelongsToGetAssociationMixin<RallyModel>
+  setRally!: Sequelize.BelongsToSetAssociationMixin<RallyModel, RallyId>
+  createRally!: Sequelize.BelongsToCreateAssociationMixin<RallyModel>
+  // Score belongsTo Team via team_id
+  team!: TeamModel
+  getTeam!: Sequelize.BelongsToGetAssociationMixin<TeamModel>
+  setTeam!: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>
+  createTeam!: Sequelize.BelongsToCreateAssociationMixin<TeamModel>
+
+  static initModel (sequelize: Sequelize.Sequelize): typeof ScoreModel {
+    return ScoreModel.init({
+      event_id: {
+        type: DataTypes.UUID,
+        allowNull: false,
+        primaryKey: true
+      },
+      rally_id: {
+        type: DataTypes.UUID,
+        allowNull: false,
+        references: {
+          model: 'Rally',
+          key: 'rally_id'
+        }
+      },
+      event_type: {
+        type: DataTypes.ENUM('LIBERO_REPLACEMENT', 'SUBSTITUTION', 'SERVE', 'RECEPTION', 'SET', 'SPIKE', 'BLOCK', 'SCORE'),
+        allowNull: false
+      },
+      team_id: {
+        type: DataTypes.UUID,
+        allowNull: false,
+        references: {
+          model: 'Team',
+          key: 'team_id'
+        }
+      },
+      order: {
+        type: DataTypes.INTEGER,
+        allowNull: false
+      },
+      player_id: {
+        type: DataTypes.UUID,
+        allowNull: false,
+        references: {
+          model: 'Player',
+          key: 'player_id'
+        }
+      }
+    }, {
+      sequelize,
+      tableName: 'Score',
+      schema: 'public',
+      timestamps: false,
+      indexes: [
+        {
+          name: 'Score_pk',
+          unique: true,
+          fields: [
+            { name: 'event_id' }
+          ]
+        }
+      ]
+    })
+  }
+}

package/src/data/models/season-teams.ts

@@ -0,0 +1,67 @@
+import * as Sequelize from 'sequelize'
+import { DataTypes, Model } from 'sequelize'
+import type { SeasonId, SeasonModel } from './season'
+import type { TeamId, TeamModel } from './team'
+
+export interface SeasonTeamsAttributes {
+  season_id: string
+  team_id: string
+}
+
+export type SeasonTeamsPk = 'season_id' | 'team_id'
+export type SeasonTeamsId = SeasonTeamsModel[SeasonTeamsPk]
+export type SeasonTeamsCreationAttributes = SeasonTeamsAttributes
+
+export class SeasonTeamsModel extends Model<SeasonTeamsAttributes, SeasonTeamsCreationAttributes> implements SeasonTeamsAttributes {
+  season_id!: string
+  team_id!: string
+
+  // SeasonTeams belongsTo Season via season_id
+  season!: SeasonModel
+  getSeason!: Sequelize.BelongsToGetAssociationMixin<SeasonModel>
+  setSeason!: Sequelize.BelongsToSetAssociationMixin<SeasonModel, SeasonId>
+  createSeason!: Sequelize.BelongsToCreateAssociationMixin<SeasonModel>
+  // SeasonTeams belongsTo Team via team_id
+  team!: TeamModel
+  getTeam!: Sequelize.BelongsToGetAssociationMixin<TeamModel>
+  setTeam!: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>
+  createTeam!: Sequelize.BelongsToCreateAssociationMixin<TeamModel>
+
+  static initModel (sequelize: Sequelize.Sequelize): typeof SeasonTeamsModel {
+    return SeasonTeamsModel.init({
+      season_id: {
+        type: DataTypes.UUID,
+        allowNull: false,
+        primaryKey: true,
+        references: {
+          model: 'Season',
+          key: 'season_id'
+        }
+      },
+      team_id: {
+        type: DataTypes.UUID,
+        allowNull: false,
+        primaryKey: true,
+        references: {
+          model: 'Team',
+          key: 'team_id'
+        }
+      }
+    }, {
+      sequelize,
+      tableName: 'SeasonTeams',
+      schema: 'public',
+      timestamps: false,
+      indexes: [
+        {
+          name: 'SeasonTeams_pk',
+          unique: true,
+          fields: [
+            { name: 'season_id' },
+            { name: 'team_id' }
+          ]
+        }
+      ]
+    })
+  }
+}

package/src/data/models/season.ts

@@ -0,0 +1,103 @@
+import * as Sequelize from 'sequelize'
+import { DataTypes, Model } from 'sequelize'
+import type { LeagueAttributes, LeagueId, LeagueModel } from './league'
+import type { MatchAttributes, MatchId, MatchModel } from './match'
+import type { SeasonTeamsId, SeasonTeamsModel } from './season-teams'
+import type { TeamAttributes, TeamId, TeamModel } from './team'
+
+export interface SeasonAttributes {
+  season_id: string
+  iteration: number
+  league_id: string
+  seasonTeams?: TeamAttributes[]
+  Matches?: MatchAttributes[]
+  league?: LeagueAttributes
+}
+
+export type SeasonPk = 'season_id'
+export type SeasonId = SeasonModel[SeasonPk]
+export type SeasonCreationAttributes = SeasonAttributes
+
+export class SeasonModel extends Model<SeasonAttributes, SeasonCreationAttributes> implements SeasonAttributes {
+  season_id!: string
+  iteration!: number
+  league_id!: string
+
+  // Season belongsTo League via league_id
+  league!: LeagueModel
+  getLeague!: Sequelize.BelongsToGetAssociationMixin<LeagueModel>
+  setLeague!: Sequelize.BelongsToSetAssociationMixin<LeagueModel, LeagueId>
+  createLeague!: Sequelize.BelongsToCreateAssociationMixin<LeagueModel>
+  // Season hasMany Match via season_id
+  Matches!: MatchModel[]
+  getMatches!: Sequelize.HasManyGetAssociationsMixin<MatchModel>
+  setMatches!: Sequelize.HasManySetAssociationsMixin<MatchModel, MatchId>
+  addMatch!: Sequelize.HasManyAddAssociationMixin<MatchModel, MatchId>
+  addMatches!: Sequelize.HasManyAddAssociationsMixin<MatchModel, MatchId>
+  createMatch!: Sequelize.HasManyCreateAssociationMixin<MatchModel>
+  removeMatch!: Sequelize.HasManyRemoveAssociationMixin<MatchModel, MatchId>
+  removeMatches!: Sequelize.HasManyRemoveAssociationsMixin<MatchModel, MatchId>
+  hasMatch!: Sequelize.HasManyHasAssociationMixin<MatchModel, MatchId>
+  hasMatches!: Sequelize.HasManyHasAssociationsMixin<MatchModel, MatchId>
+  countMatches!: Sequelize.HasManyCountAssociationsMixin
+  // Season hasMany SeasonTeams via season_id
+  SeasonTeams!: SeasonTeamsModel[]
+  getSeasonTeams!: Sequelize.HasManyGetAssociationsMixin<SeasonTeamsModel>
+  setSeasonTeams!: Sequelize.HasManySetAssociationsMixin<SeasonTeamsModel, SeasonTeamsId>
+  addSeasonTeam!: Sequelize.HasManyAddAssociationMixin<SeasonTeamsModel, SeasonTeamsId>
+  addSeasonTeams!: Sequelize.HasManyAddAssociationsMixin<SeasonTeamsModel, SeasonTeamsId>
+  createSeasonTeam!: Sequelize.HasManyCreateAssociationMixin<SeasonTeamsModel>
+  removeSeasonTeam!: Sequelize.HasManyRemoveAssociationMixin<SeasonTeamsModel, SeasonTeamsId>
+  removeSeasonTeams!: Sequelize.HasManyRemoveAssociationsMixin<SeasonTeamsModel, SeasonTeamsId>
+  hasSeasonTeam!: Sequelize.HasManyHasAssociationMixin<SeasonTeamsModel, SeasonTeamsId>
+  hasSeasonTeams!: Sequelize.HasManyHasAssociationsMixin<SeasonTeamsModel, SeasonTeamsId>
+  countSeasonTeams!: Sequelize.HasManyCountAssociationsMixin
+  // Season belongsToMany Team via season_id and team_id
+  seasonTeams!: TeamModel[]
+  getseasonTeams!: Sequelize.BelongsToManyGetAssociationsMixin<TeamModel>
+  setseasonTeams!: Sequelize.BelongsToManySetAssociationsMixin<TeamModel, TeamId>
+  addTeam_id_Team!: Sequelize.BelongsToManyAddAssociationMixin<TeamModel, TeamId>
+  addseasonTeams!: Sequelize.BelongsToManyAddAssociationsMixin<TeamModel, TeamId>
+  createTeam_id_Team!: Sequelize.BelongsToManyCreateAssociationMixin<TeamModel>
+  removeTeam_id_Team!: Sequelize.BelongsToManyRemoveAssociationMixin<TeamModel, TeamId>
+  removeseasonTeams!: Sequelize.BelongsToManyRemoveAssociationsMixin<TeamModel, TeamId>
+  hasTeam_id_Team!: Sequelize.BelongsToManyHasAssociationMixin<TeamModel, TeamId>
+  hasseasonTeams!: Sequelize.BelongsToManyHasAssociationsMixin<TeamModel, TeamId>
+  countseasonTeams!: Sequelize.BelongsToManyCountAssociationsMixin
+
+  static initModel (sequelize: Sequelize.Sequelize): typeof SeasonModel {
+    return SeasonModel.init({
+      season_id: {
+        type: DataTypes.UUID,
+        allowNull: false,
+        primaryKey: true
+      },
+      iteration: {
+        type: DataTypes.INTEGER,
+        allowNull: false
+      },
+      league_id: {
+        type: DataTypes.UUID,
+        allowNull: false,
+        references: {
+          model: 'League',
+          key: 'league_id'
+        }
+      }
+    }, {
+      sequelize,
+      tableName: 'Season',
+      schema: 'public',
+      timestamps: false,
+      indexes: [
+        {
+          name: 'Season_pk',
+          unique: true,
+          fields: [
+            { name: 'season_id' }
+          ]
+        }
+      ]
+    })
+  }
+}