volleyballsimtypes 0.0.1

package/src/data/models/index.ts

@@ -0,0 +1,22 @@
+export * from './block'
+export * from './coach'
+export * from './country'
+export * from './event'
+export * from './league'
+export * from './libero-replacement'
+export * from './match'
+export * from './match-set'
+export * from './match-set-stats'
+export * from './performance-stats'
+export * from './player'
+export * from './rally'
+export * from './rally-position'
+export * from './reception'
+export * from './score'
+export * from './season'
+export * from './season-teams'
+export * from './serve'
+export * from './set'
+export * from './spike'
+export * from './substitution'
+export * from './team'

package/src/data/models/league.ts

@@ -0,0 +1,90 @@
+import * as Sequelize from 'sequelize'
+import { DataTypes, Model } from 'sequelize'
+import type { CountryAttributes, CountryId, CountryModel } from './country'
+import type { SeasonAttributes, SeasonId, SeasonModel } from './season'
+import { TeamAttributes, TeamId, TeamModel } from './team'
+
+export interface LeagueAttributes {
+  league_id: string
+  country_id: string
+  name: string
+  Teams?: TeamAttributes[]
+  Seasons?: SeasonAttributes[]
+  country?: CountryAttributes
+}
+
+export type LeaguePk = 'league_id'
+export type LeagueId = LeagueModel[LeaguePk]
+export type LeagueCreationAttributes = LeagueAttributes
+
+export class LeagueModel extends Model<LeagueAttributes, LeagueCreationAttributes> implements LeagueAttributes {
+  league_id!: string
+  country_id!: string
+  name!: string
+
+  // League belongsTo Country via country_id
+  country!: CountryModel
+  getCountry!: Sequelize.BelongsToGetAssociationMixin<CountryModel>
+  setCountry!: Sequelize.BelongsToSetAssociationMixin<CountryModel, CountryId>
+  createCountry!: Sequelize.BelongsToCreateAssociationMixin<CountryModel>
+  // League hasMany Season via league_id
+  Seasons!: SeasonModel[]
+  getSeasons!: Sequelize.HasManyGetAssociationsMixin<SeasonModel>
+  setSeasons!: Sequelize.HasManySetAssociationsMixin<SeasonModel, SeasonId>
+  addSeason!: Sequelize.HasManyAddAssociationMixin<SeasonModel, SeasonId>
+  addSeasons!: Sequelize.HasManyAddAssociationsMixin<SeasonModel, SeasonId>
+  createSeason!: Sequelize.HasManyCreateAssociationMixin<SeasonModel>
+  removeSeason!: Sequelize.HasManyRemoveAssociationMixin<SeasonModel, SeasonId>
+  removeSeasons!: Sequelize.HasManyRemoveAssociationsMixin<SeasonModel, SeasonId>
+  hasSeason!: Sequelize.HasManyHasAssociationMixin<SeasonModel, SeasonId>
+  hasSeasons!: Sequelize.HasManyHasAssociationsMixin<SeasonModel, SeasonId>
+  countSeasons!: Sequelize.HasManyCountAssociationsMixin
+  // League hasMany Team via league_id
+  Teams!: TeamModel[]
+  getTeams!: Sequelize.HasManyGetAssociationsMixin<TeamModel>
+  setTeams!: Sequelize.HasManySetAssociationsMixin<TeamModel, TeamId>
+  addTeam!: Sequelize.HasManyAddAssociationMixin<TeamModel, TeamId>
+  addTeams!: Sequelize.HasManyAddAssociationsMixin<TeamModel, TeamId>
+  createTeam!: Sequelize.HasManyCreateAssociationMixin<TeamModel>
+  removeTeam!: Sequelize.HasManyRemoveAssociationMixin<TeamModel, TeamId>
+  removeTeams!: Sequelize.HasManyRemoveAssociationsMixin<TeamModel, TeamId>
+  hasTeam!: Sequelize.HasManyHasAssociationMixin<TeamModel, TeamId>
+  hasTeams!: Sequelize.HasManyHasAssociationsMixin<TeamModel, TeamId>
+  countTeams!: Sequelize.HasManyCountAssociationsMixin
+
+  static initModel (sequelize: Sequelize.Sequelize): typeof LeagueModel {
+    return LeagueModel.init({
+      league_id: {
+        type: DataTypes.UUID,
+        allowNull: false,
+        primaryKey: true
+      },
+      country_id: {
+        type: DataTypes.UUID,
+        allowNull: false,
+        references: {
+          model: 'Country',
+          key: 'country_id'
+        }
+      },
+      name: {
+        type: DataTypes.STRING,
+        allowNull: false
+      }
+    }, {
+      sequelize,
+      tableName: 'League',
+      schema: 'public',
+      timestamps: false,
+      indexes: [
+        {
+          name: 'League_pk',
+          unique: true,
+          fields: [
+            { name: 'league_id' }
+          ]
+        }
+      ]
+    })
+  }
+}

package/src/data/models/libero-replacement.ts

@@ -0,0 +1,104 @@
+import * as Sequelize from 'sequelize'
+import { DataTypes, Model } from 'sequelize'
+import type { PlayerId, PlayerModel } from './player'
+import type { RallyId, RallyModel } from './rally'
+
+export interface LiberoReplacementAttributes {
+  event_id: string
+  rally_id: string
+  event_type: 'LIBERO_REPLACEMENT' | 'SUBSTITUTION' | 'SERVE' | 'RECEPTION' | 'SET' | 'SPIKE' | 'BLOCK' | 'SCORE'
+  type: 'LIBERO_IN' | 'LIBERO_OUT'
+  libero: string
+  order: number
+  player_id: string
+}
+
+export type LiberoReplacementPk = 'event_id'
+export type LiberoReplacementId = LiberoReplacementModel[LiberoReplacementPk]
+export type LiberoReplacementCreationAttributes = LiberoReplacementAttributes
+
+export class LiberoReplacementModel extends Model<LiberoReplacementAttributes, LiberoReplacementCreationAttributes> implements LiberoReplacementAttributes {
+  event_id!: string
+  rally_id!: string
+  event_type!: 'LIBERO_REPLACEMENT' | 'SUBSTITUTION' | 'SERVE' | 'RECEPTION' | 'SET' | 'SPIKE' | 'BLOCK' | 'SCORE'
+  type!: 'LIBERO_IN' | 'LIBERO_OUT'
+  libero!: string
+  order!: number
+  player_id!: string
+
+  // LiberoReplacement belongsTo Player via libero
+  libero_Player!: PlayerModel
+  getLibero_Player!: Sequelize.BelongsToGetAssociationMixin<PlayerModel>
+  setLibero_Player!: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>
+  createLibero_Player!: Sequelize.BelongsToCreateAssociationMixin<PlayerModel>
+  // LiberoReplacement belongsTo Player via player_id
+  player!: PlayerModel
+  getPlayer!: Sequelize.BelongsToGetAssociationMixin<PlayerModel>
+  setPlayer!: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>
+  createPlayer!: Sequelize.BelongsToCreateAssociationMixin<PlayerModel>
+  // LiberoReplacement 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 LiberoReplacementModel {
+    return LiberoReplacementModel.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
+      },
+      type: {
+        type: DataTypes.ENUM('LIBERO_IN', 'LIBERO_OUT'),
+        allowNull: false
+      },
+      libero: {
+        type: DataTypes.UUID,
+        allowNull: false,
+        references: {
+          model: 'Player',
+          key: 'player_id'
+        }
+      },
+      order: {
+        type: DataTypes.INTEGER,
+        allowNull: false
+      },
+      player_id: {
+        type: DataTypes.UUID,
+        allowNull: false,
+        references: {
+          model: 'Player',
+          key: 'player_id'
+        }
+      }
+    }, {
+      sequelize,
+      tableName: 'LiberoReplacement',
+      schema: 'public',
+      timestamps: false,
+      indexes: [
+        {
+          name: 'LiberoReplacement_pk',
+          unique: true,
+          fields: [
+            { name: 'event_id' }
+          ]
+        }
+      ]
+    })
+  }
+}

package/src/data/models/match-set-stats.ts

@@ -0,0 +1,204 @@
+import * as Sequelize from 'sequelize'
+import { DataTypes, Model, Optional } from 'sequelize'
+import type { MatchSetId, MatchSetModel } from './match-set'
+import type { PlayerId, PlayerModel } from './player'
+
+export interface MatchSetStatsAttributes {
+  player_id: string
+  match_set_id: string
+  aces: number
+  attempts: number
+  contacts: number
+  rallies_played: number
+  serve_success: number
+  serve_error: number
+  reception_success: number
+  reception_error: number
+  set_success: number
+  set_error: number
+  attack_success: number
+  attack_error: number
+  block_success: number
+  block_error: number
+  kills: number
+  kill_blocks: number
+  assists: number
+}
+
+export type MatchSetStatsPk = 'player_id' | 'match_set_id'
+export type MatchSetStatsId = MatchSetStatsModel[MatchSetStatsPk]
+export type MatchSetStatsOptionalAttributes =
+  'aces'
+  | 'attempts'
+  | 'contacts'
+  | 'rallies_played'
+  | 'serve_success'
+  | 'serve_error'
+  | 'reception_success'
+  | 'reception_error'
+  | 'set_success'
+  | 'set_error'
+  | 'attack_success'
+  | 'attack_error'
+  | 'block_success'
+  | 'block_error'
+  | 'kills'
+  | 'kill_blocks'
+  | 'assists'
+export type MatchSetStatsCreationAttributes = Optional<MatchSetStatsAttributes, MatchSetStatsOptionalAttributes>
+
+export class MatchSetStatsModel extends Model<MatchSetStatsAttributes, MatchSetStatsCreationAttributes> implements MatchSetStatsAttributes {
+  player_id!: string
+  match_set_id!: string
+  aces!: number
+  attempts!: number
+  contacts!: number
+  rallies_played!: number
+  serve_success!: number
+  serve_error!: number
+  reception_success!: number
+  reception_error!: number
+  set_success!: number
+  set_error!: number
+  attack_success!: number
+  attack_error!: number
+  block_success!: number
+  block_error!: number
+  kills!: number
+  kill_blocks!: number
+  assists!: number
+
+  // MatchSetStats 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>
+  // MatchSetStats belongsTo Player via player_id
+  player!: PlayerModel
+  getPlayer!: Sequelize.BelongsToGetAssociationMixin<PlayerModel>
+  setPlayer!: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>
+  createPlayer!: Sequelize.BelongsToCreateAssociationMixin<PlayerModel>
+
+  static initModel (sequelize: Sequelize.Sequelize): typeof MatchSetStatsModel {
+    return MatchSetStatsModel.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'
+        }
+      },
+      aces: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0
+      },
+      attempts: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0
+      },
+      contacts: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0
+      },
+      rallies_played: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0
+      },
+      serve_success: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0
+      },
+      serve_error: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0
+      },
+      reception_success: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0
+      },
+      reception_error: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0
+      },
+      set_success: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0
+      },
+      set_error: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0
+      },
+      attack_success: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0
+      },
+      attack_error: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0
+      },
+      block_success: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0
+      },
+      block_error: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0
+      },
+      kills: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0
+      },
+      kill_blocks: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0
+      },
+      assists: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0
+      }
+    }, {
+      sequelize,
+      tableName: 'MatchSetStats',
+      schema: 'public',
+      timestamps: false,
+      indexes: [
+        {
+          name: 'MatchSetStats_pk',
+          unique: true,
+          fields: [
+            { name: 'player_id' },
+            { name: 'match_set_id' }
+          ]
+        }
+      ]
+    })
+  }
+}

package/src/data/models/match-set.ts

@@ -0,0 +1,152 @@
+import * as Sequelize from 'sequelize'
+import { DataTypes, Model, Optional } from 'sequelize'
+import type { MatchId, MatchModel } from './match'
+import type { MatchSetStatsAttributes, MatchSetStatsId, MatchSetStatsModel } from './match-set-stats'
+import type { PlayerId, PlayerModel } from './player'
+import type { RallyAttributes, RallyId, RallyModel } from './rally'
+
+export interface MatchSetAttributes {
+  match_set_id: string
+  match_id: string
+  is_tie_break: boolean
+  order: number
+  home_score: number
+  away_score: number
+  home_libero?: string
+  away_libero?: string
+  Rallies?: RallyAttributes[]
+  MatchSetStats?: MatchSetStatsAttributes[]
+}
+
+export type MatchSetPk = 'match_set_id'
+export type MatchSetId = MatchSetModel[MatchSetPk]
+export type MatchSetOptionalAttributes = 'home_libero' | 'away_libero'
+export type MatchSetCreationAttributes = Optional<MatchSetAttributes, MatchSetOptionalAttributes>
+
+export class MatchSetModel extends Model<MatchSetAttributes, MatchSetCreationAttributes> implements MatchSetAttributes {
+  match_set_id!: string
+  match_id!: string
+  is_tie_break!: boolean
+  home_libero?: string
+  away_libero?: string
+  order!: number
+  home_score!: number
+  away_score!: number
+
+  // MatchSet belongsTo Match via match_id
+  match!: MatchModel
+  getMatch!: Sequelize.BelongsToGetAssociationMixin<MatchModel>
+  setMatch!: Sequelize.BelongsToSetAssociationMixin<MatchModel, MatchId>
+  createMatch!: Sequelize.BelongsToCreateAssociationMixin<MatchModel>
+  // MatchSet hasMany MatchSetStats via match_set_id
+  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
+  // MatchSet belongsToMany Player via match_set_id and player_id
+  player_id_Players!: PlayerModel[]
+  getPlayer_id_Players!: Sequelize.BelongsToManyGetAssociationsMixin<PlayerModel>
+  setPlayer_id_Players!: Sequelize.BelongsToManySetAssociationsMixin<PlayerModel, PlayerId>
+  addPlayer_id_Player!: Sequelize.BelongsToManyAddAssociationMixin<PlayerModel, PlayerId>
+  addPlayer_id_Players!: Sequelize.BelongsToManyAddAssociationsMixin<PlayerModel, PlayerId>
+  createPlayer_id_Player!: Sequelize.BelongsToManyCreateAssociationMixin<PlayerModel>
+  removePlayer_id_Player!: Sequelize.BelongsToManyRemoveAssociationMixin<PlayerModel, PlayerId>
+  removePlayer_id_Players!: Sequelize.BelongsToManyRemoveAssociationsMixin<PlayerModel, PlayerId>
+  hasPlayer_id_Player!: Sequelize.BelongsToManyHasAssociationMixin<PlayerModel, PlayerId>
+  hasPlayer_id_Players!: Sequelize.BelongsToManyHasAssociationsMixin<PlayerModel, PlayerId>
+  countPlayer_id_Players!: Sequelize.BelongsToManyCountAssociationsMixin
+  // MatchSet hasMany Rally via match_set_id
+  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
+  // MatchSet belongsTo Player via away_libero
+  away_libero_Player!: PlayerModel
+  getAway_libero_Player!: Sequelize.BelongsToGetAssociationMixin<PlayerModel>
+  setAway_libero_Player!: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>
+  createAway_libero_Player!: Sequelize.BelongsToCreateAssociationMixin<PlayerModel>
+  // MatchSet belongsTo Player via home_libero
+  home_libero_Player!: PlayerModel
+  getHome_libero_Player!: Sequelize.BelongsToGetAssociationMixin<PlayerModel>
+  setHome_libero_Player!: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>
+  createHome_libero_Player!: Sequelize.BelongsToCreateAssociationMixin<PlayerModel>
+
+  static initModel (sequelize: Sequelize.Sequelize): typeof MatchSetModel {
+    return MatchSetModel.init({
+      match_set_id: {
+        type: DataTypes.UUID,
+        allowNull: false,
+        primaryKey: true
+      },
+      match_id: {
+        type: DataTypes.UUID,
+        allowNull: false,
+        references: {
+          model: 'Match',
+          key: 'match_id'
+        }
+      },
+      is_tie_break: {
+        type: DataTypes.BOOLEAN,
+        allowNull: false,
+        defaultValue: false
+      },
+      home_libero: {
+        type: DataTypes.UUID,
+        allowNull: true,
+        references: {
+          model: 'Player',
+          key: 'player_id'
+        }
+      },
+      away_libero: {
+        type: DataTypes.UUID,
+        allowNull: true,
+        references: {
+          model: 'Player',
+          key: 'player_id'
+        }
+      },
+      order: {
+        type: DataTypes.INTEGER,
+        allowNull: false
+      },
+      home_score: {
+        type: DataTypes.INTEGER,
+        allowNull: false
+      },
+      away_score: {
+        type: DataTypes.INTEGER,
+        allowNull: false
+      }
+    }, {
+      sequelize,
+      tableName: 'MatchSet',
+      schema: 'public',
+      timestamps: false,
+      indexes: [
+        {
+          name: 'MatchSet_pk',
+          unique: true,
+          fields: [
+            { name: 'match_set_id' }
+          ]
+        }
+      ]
+    })
+  }
+}

package/src/data/models/match.ts

@@ -0,0 +1,106 @@
+import * as Sequelize from 'sequelize'
+import { DataTypes, Model } from 'sequelize'
+import type { MatchSetAttributes, MatchSetId, MatchSetModel } from './match-set'
+import type { SeasonId, SeasonModel } from './season'
+import type { TeamId, TeamModel } from './team'
+
+export interface MatchAttributes {
+  match_id: string
+  home_team: string
+  away_team: string
+  scheduled_date: string
+  season_id: string
+  MatchSets?: MatchSetAttributes[]
+}
+
+export type MatchPk = 'match_id'
+export type MatchId = MatchModel[MatchPk]
+export type MatchCreationAttributes = MatchAttributes
+
+export class MatchModel extends Model<MatchAttributes, MatchCreationAttributes> implements MatchAttributes {
+  match_id!: string
+  home_team!: string
+  away_team!: string
+  scheduled_date!: string
+  season_id!: string
+
+  // Match hasMany MatchSet via match_id
+  MatchSets!: MatchSetModel[]
+  getMatchSets!: Sequelize.HasManyGetAssociationsMixin<MatchSetModel>
+  setMatchSets!: Sequelize.HasManySetAssociationsMixin<MatchSetModel, MatchSetId>
+  addMatchSet!: Sequelize.HasManyAddAssociationMixin<MatchSetModel, MatchSetId>
+  addMatchSets!: Sequelize.HasManyAddAssociationsMixin<MatchSetModel, MatchSetId>
+  createMatchSet!: Sequelize.HasManyCreateAssociationMixin<MatchSetModel>
+  removeMatchSet!: Sequelize.HasManyRemoveAssociationMixin<MatchSetModel, MatchSetId>
+  removeMatchSets!: Sequelize.HasManyRemoveAssociationsMixin<MatchSetModel, MatchSetId>
+  hasMatchSet!: Sequelize.HasManyHasAssociationMixin<MatchSetModel, MatchSetId>
+  hasMatchSets!: Sequelize.HasManyHasAssociationsMixin<MatchSetModel, MatchSetId>
+  countMatchSets!: Sequelize.HasManyCountAssociationsMixin
+  // Match belongsTo Season via season_id
+  season!: SeasonModel
+  getSeason!: Sequelize.BelongsToGetAssociationMixin<SeasonModel>
+  setSeason!: Sequelize.BelongsToSetAssociationMixin<SeasonModel, SeasonId>
+  createSeason!: Sequelize.BelongsToCreateAssociationMixin<SeasonModel>
+  // Match belongsTo Team via home_team
+  homeTeam!: TeamModel
+  getHomeTeam!: Sequelize.BelongsToGetAssociationMixin<TeamModel>
+  setHomeTeam!: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>
+  createHomeTeam!: Sequelize.BelongsToCreateAssociationMixin<TeamModel>
+  // Match belongsTo Team via away_team
+  awayTeam!: TeamModel
+  getAwayTeam!: Sequelize.BelongsToGetAssociationMixin<TeamModel>
+  setAwayTeam!: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>
+  createAwayTeam!: Sequelize.BelongsToCreateAssociationMixin<TeamModel>
+
+  static initModel (sequelize: Sequelize.Sequelize): typeof MatchModel {
+    return MatchModel.init({
+      match_id: {
+        type: DataTypes.UUID,
+        allowNull: false,
+        primaryKey: true
+      },
+      home_team: {
+        type: DataTypes.UUID,
+        allowNull: false,
+        references: {
+          model: 'Team',
+          key: 'team_id'
+        }
+      },
+      away_team: {
+        type: DataTypes.UUID,
+        allowNull: false,
+        references: {
+          model: 'Team',
+          key: 'team_id'
+        }
+      },
+      scheduled_date: {
+        type: DataTypes.DATEONLY,
+        allowNull: false
+      },
+      season_id: {
+        type: DataTypes.UUID,
+        allowNull: false,
+        references: {
+          model: 'Season',
+          key: 'season_id'
+        }
+      }
+    }, {
+      sequelize,
+      tableName: 'Match',
+      schema: 'public',
+      timestamps: false,
+      indexes: [
+        {
+          name: 'Match_pk',
+          unique: true,
+          fields: [
+            { name: 'match_id' }
+          ]
+        }
+      ]
+    })
+  }
+}