volleyballsimtypes 0.0.7 → 0.0.9

package/src/data/models/rally.ts

@@ -1,229 +0,0 @@
-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

@@ -1,113 +0,0 @@
-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

@@ -1,99 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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

@@ -1,103 +0,0 @@
-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' }
-          ]
-        }
-      ]
-    })
-  }
-}