volleyballsimtypes 0.0.1

package/src/data/models/serve.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 ServeAttributes {
+  event_id: string
+  rally_id: string
+  event_type: 'LIBERO_REPLACEMENT' | 'SUBSTITUTION' | 'SERVE' | 'RECEPTION' | 'SET' | 'SPIKE' | 'BLOCK' | 'SCORE'
+  failure: 'NO_FAILURE' | 'FAULT' | 'MISS' | 'NET' | 'OUT_OF_BOUNDS'
+  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
+  type: 'UNDERHAND' | 'OVERHAND_TOPSPIN' | 'OVERHAND_FLOAT' | 'JUMP_TOPSPIN' | 'JUMP_FLOAT'
+}
+
+export type ServePk = 'event_id'
+export type ServeId = ServeModel[ServePk]
+export type ServeCreationAttributes = ServeAttributes
+
+export class ServeModel extends Model<ServeAttributes, ServeCreationAttributes> implements ServeAttributes {
+  event_id!: string
+  rally_id!: string
+  event_type!: 'LIBERO_REPLACEMENT' | 'SUBSTITUTION' | 'SERVE' | 'RECEPTION' | 'SET' | 'SPIKE' | 'BLOCK' | 'SCORE'
+  failure!: 'NO_FAILURE' | 'FAULT' | 'MISS' | 'NET' | 'OUT_OF_BOUNDS'
+  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
+  type!: 'UNDERHAND' | 'OVERHAND_TOPSPIN' | 'OVERHAND_FLOAT' | 'JUMP_TOPSPIN' | 'JUMP_FLOAT'
+
+  // Serve belongsTo Player via player_id
+  player!: PlayerModel
+  getPlayer!: Sequelize.BelongsToGetAssociationMixin<PlayerModel>
+  setPlayer!: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>
+  createPlayer!: Sequelize.BelongsToCreateAssociationMixin<PlayerModel>
+  // Serve 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 ServeModel {
+    return ServeModel.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', 'NET', 'OUT_OF_BOUNDS'),
+        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
+      },
+      type: {
+        type: DataTypes.ENUM('UNDERHAND', 'OVERHAND_TOPSPIN', 'OVERHAND_FLOAT', 'JUMP_TOPSPIN', 'JUMP_FLOAT'),
+        allowNull: false
+      }
+    }, {
+      sequelize,
+      tableName: 'Serve',
+      schema: 'public',
+      timestamps: false,
+      indexes: [
+        {
+          name: 'Serve_pk',
+          unique: true,
+          fields: [
+            { name: 'event_id' }
+          ]
+        }
+      ]
+    })
+  }
+}

package/src/data/models/set.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 SetAttributes {
+  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: 'OVERHAND' | 'UNDERHAND' | 'SPIKE' | 'DUMP'
+  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 SetPk = 'event_id'
+export type SetId = SetModel[SetPk]
+export type SetCreationAttributes = SetAttributes
+
+export class SetModel extends Model<SetAttributes, SetCreationAttributes> implements SetAttributes {
+  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!: 'OVERHAND' | 'UNDERHAND' | 'SPIKE' | 'DUMP'
+  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
+
+  // Set belongsTo Player via player_id
+  player!: PlayerModel
+  getPlayer!: Sequelize.BelongsToGetAssociationMixin<PlayerModel>
+  setPlayer!: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>
+  createPlayer!: Sequelize.BelongsToCreateAssociationMixin<PlayerModel>
+  // Set 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 SetModel {
+    return SetModel.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('OVERHAND', 'UNDERHAND', 'SPIKE', 'DUMP'),
+        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: 'Set',
+      schema: 'public',
+      timestamps: false,
+      indexes: [
+        {
+          name: 'Set_pk',
+          unique: true,
+          fields: [
+            { name: 'event_id' }
+          ]
+        }
+      ]
+    })
+  }
+}

package/src/data/models/spike.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 SpikeAttributes {
+  event_id: string
+  rally_id: string
+  event_type: 'LIBERO_REPLACEMENT' | 'SUBSTITUTION' | 'SERVE' | 'RECEPTION' | 'SET' | 'SPIKE' | 'BLOCK' | 'SCORE'
+  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'
+  type: 'CROSS_SHOT' | 'LINE_SHOT' | 'TOOL_SHOT' | 'TIP' | 'DOWN_BALL' | 'OVERHAND'
+  failure: 'NO_FAILURE' | 'FAULT' | 'MISS' | 'OUT_OF_BOUNDS' | 'NET'
+  order: number
+  player_id: string
+  modifier: number
+  score: number
+}
+
+export type SpikePk = 'event_id'
+export type SpikeId = SpikeModel[SpikePk]
+export type SpikeCreationAttributes = SpikeAttributes
+
+export class SpikeModel extends Model<SpikeAttributes, SpikeCreationAttributes> implements SpikeAttributes {
+  event_id!: string
+  rally_id!: string
+  event_type!: 'LIBERO_REPLACEMENT' | 'SUBSTITUTION' | 'SERVE' | 'RECEPTION' | 'SET' | 'SPIKE' | 'BLOCK' | 'SCORE'
+  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'
+  type!: 'CROSS_SHOT' | 'LINE_SHOT' | 'TOOL_SHOT' | 'TIP' | 'DOWN_BALL' | 'OVERHAND'
+  failure!: 'NO_FAILURE' | 'FAULT' | 'MISS' | 'OUT_OF_BOUNDS' | 'NET'
+  order!: number
+  player_id!: string
+  modifier!: number
+  score!: number
+
+  // Spike belongsTo Player via player_id
+  player!: PlayerModel
+  getPlayer!: Sequelize.BelongsToGetAssociationMixin<PlayerModel>
+  setPlayer!: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>
+  createPlayer!: Sequelize.BelongsToCreateAssociationMixin<PlayerModel>
+  // Spike 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 SpikeModel {
+    return SpikeModel.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
+      },
+      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
+      },
+      type: {
+        type: DataTypes.ENUM('CROSS_SHOT', 'LINE_SHOT', 'TOOL_SHOT', 'TIP', 'DOWN_BALL', 'OVERHAND'),
+        allowNull: false
+      },
+      failure: {
+        type: DataTypes.ENUM('NO_FAILURE', 'FAULT', 'MISS', 'OUT_OF_BOUNDS', 'NET'),
+        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: 'Spike',
+      schema: 'public',
+      timestamps: false,
+      indexes: [
+        {
+          name: 'Spike_pk',
+          unique: true,
+          fields: [
+            { name: 'event_id' }
+          ]
+        }
+      ]
+    })
+  }
+}

package/src/data/models/substitution.ts

@@ -0,0 +1,98 @@
+import * as Sequelize from 'sequelize'
+import { DataTypes, Model } from 'sequelize'
+import type { PlayerId, PlayerModel } from './player'
+import type { RallyId, RallyModel } from './rally'
+
+export interface SubstitutionAttributes {
+  event_id: string
+  rally_id: string
+  event_type: 'LIBERO_REPLACEMENT' | 'SUBSTITUTION' | 'SERVE' | 'RECEPTION' | 'SET' | 'SPIKE' | 'BLOCK' | 'SCORE'
+  player_out: string
+  order: number
+  player_id: string
+}
+
+export type SubstitutionPk = 'event_id'
+export type SubstitutionId = SubstitutionModel[SubstitutionPk]
+export type SubstitutionCreationAttributes = SubstitutionAttributes
+
+export class SubstitutionModel extends Model<SubstitutionAttributes, SubstitutionCreationAttributes> implements SubstitutionAttributes {
+  event_id!: string
+  rally_id!: string
+  event_type!: 'LIBERO_REPLACEMENT' | 'SUBSTITUTION' | 'SERVE' | 'RECEPTION' | 'SET' | 'SPIKE' | 'BLOCK' | 'SCORE'
+  player_out!: string
+  order!: number
+  player_id!: string
+
+  // Substitution belongsTo Player via player_out
+  player_out_Player!: PlayerModel
+  getPlayer_out_Player!: Sequelize.BelongsToGetAssociationMixin<PlayerModel>
+  setPlayer_out_Player!: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>
+  createPlayer_out_Player!: Sequelize.BelongsToCreateAssociationMixin<PlayerModel>
+  // Substitution belongsTo Player via player_id
+  player!: PlayerModel
+  getPlayer!: Sequelize.BelongsToGetAssociationMixin<PlayerModel>
+  setPlayer!: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>
+  createPlayer!: Sequelize.BelongsToCreateAssociationMixin<PlayerModel>
+  // Substitution 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 SubstitutionModel {
+    return SubstitutionModel.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
+      },
+      player_out: {
+        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: 'Substitution',
+      schema: 'public',
+      timestamps: false,
+      indexes: [
+        {
+          name: 'Substitution_pk',
+          unique: true,
+          fields: [
+            { name: 'event_id' }
+          ]
+        }
+      ]
+    })
+  }
+}

package/src/data/models/team.ts

@@ -0,0 +1,193 @@
+import * as Sequelize from 'sequelize'
+import { DataTypes, Model } from 'sequelize'
+import type { CoachAttributes, CoachId, CoachModel } from './coach'
+import type { CountryId, CountryModel } from './country'
+import type { MatchId, MatchModel } from './match'
+import type { PlayerId, PlayerModel } from './player'
+import type { RallyId, RallyModel } from './rally'
+import type { ScoreId, ScoreModel } from './score'
+import type { SeasonId, SeasonModel } from './season'
+import type { SeasonTeamsId, SeasonTeamsModel } from './season-teams'
+import { LeagueAttributes, LeagueId, LeagueModel } from './league'
+
+export interface TeamAttributes {
+  team_id: string
+  coach_id: string
+  league_id: string
+  name: string
+  short_name: string
+  country_id: string
+  coach?: CoachAttributes
+  league?: LeagueAttributes
+}
+
+export type TeamPk = 'team_id'
+export type TeamId = TeamModel[TeamPk]
+export type TeamCreationAttributes = TeamAttributes
+
+export 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
+
+  // Team belongsTo Coach via coach_id
+  coach!: CoachModel
+  getCoach!: Sequelize.BelongsToGetAssociationMixin<CoachModel>
+  setCoach!: Sequelize.BelongsToSetAssociationMixin<CoachModel, CoachId>
+  createCoach!: Sequelize.BelongsToCreateAssociationMixin<CoachModel>
+  // Team belongsTo Country via country_id
+  country!: CountryModel
+  getCountry!: Sequelize.BelongsToGetAssociationMixin<CountryModel>
+  setCountry!: Sequelize.BelongsToSetAssociationMixin<CountryModel, CountryId>
+  createCountry!: Sequelize.BelongsToCreateAssociationMixin<CountryModel>
+  // Team belongsTo League via league_id
+  league!: LeagueModel
+  getLeague!: Sequelize.BelongsToGetAssociationMixin<LeagueModel>
+  setLeague!: Sequelize.BelongsToSetAssociationMixin<LeagueModel, LeagueId>
+  createLeague!: Sequelize.BelongsToCreateAssociationMixin<LeagueModel>
+  // Team hasMany Match via home_team
+  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
+  // Team hasMany Match via away_team
+  away_team_Matches!: MatchModel[]
+  getAway_team_Matches!: Sequelize.HasManyGetAssociationsMixin<MatchModel>
+  setAway_team_Matches!: Sequelize.HasManySetAssociationsMixin<MatchModel, MatchId>
+  addAway_team_Match!: Sequelize.HasManyAddAssociationMixin<MatchModel, MatchId>
+  addAway_team_Matches!: Sequelize.HasManyAddAssociationsMixin<MatchModel, MatchId>
+  createAway_team_Match!: Sequelize.HasManyCreateAssociationMixin<MatchModel>
+  removeAway_team_Match!: Sequelize.HasManyRemoveAssociationMixin<MatchModel, MatchId>
+  removeAway_team_Matches!: Sequelize.HasManyRemoveAssociationsMixin<MatchModel, MatchId>
+  hasAway_team_Match!: Sequelize.HasManyHasAssociationMixin<MatchModel, MatchId>
+  hasAway_team_Matches!: Sequelize.HasManyHasAssociationsMixin<MatchModel, MatchId>
+  countAway_team_Matches!: Sequelize.HasManyCountAssociationsMixin
+  // Team hasMany Player via team_id
+  Players!: PlayerModel[]
+  getPlayers!: Sequelize.HasManyGetAssociationsMixin<PlayerModel>
+  setPlayers!: Sequelize.HasManySetAssociationsMixin<PlayerModel, PlayerId>
+  addPlayer!: Sequelize.HasManyAddAssociationMixin<PlayerModel, PlayerId>
+  addPlayers!: Sequelize.HasManyAddAssociationsMixin<PlayerModel, PlayerId>
+  createPlayer!: Sequelize.HasManyCreateAssociationMixin<PlayerModel>
+  removePlayer!: Sequelize.HasManyRemoveAssociationMixin<PlayerModel, PlayerId>
+  removePlayers!: Sequelize.HasManyRemoveAssociationsMixin<PlayerModel, PlayerId>
+  hasPlayer!: Sequelize.HasManyHasAssociationMixin<PlayerModel, PlayerId>
+  hasPlayers!: Sequelize.HasManyHasAssociationsMixin<PlayerModel, PlayerId>
+  countPlayers!: Sequelize.HasManyCountAssociationsMixin
+  // Team hasMany Rally via serving_team
+  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
+  // Team hasMany Score via team_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
+  // Team belongsToMany Season via team_id and season_id
+  season_id_Seasons!: SeasonModel[]
+  getSeason_id_Seasons!: Sequelize.BelongsToManyGetAssociationsMixin<SeasonModel>
+  setSeason_id_Seasons!: Sequelize.BelongsToManySetAssociationsMixin<SeasonModel, SeasonId>
+  addSeason_id_Season!: Sequelize.BelongsToManyAddAssociationMixin<SeasonModel, SeasonId>
+  addSeason_id_Seasons!: Sequelize.BelongsToManyAddAssociationsMixin<SeasonModel, SeasonId>
+  createSeason_id_Season!: Sequelize.BelongsToManyCreateAssociationMixin<SeasonModel>
+  removeSeason_id_Season!: Sequelize.BelongsToManyRemoveAssociationMixin<SeasonModel, SeasonId>
+  removeSeason_id_Seasons!: Sequelize.BelongsToManyRemoveAssociationsMixin<SeasonModel, SeasonId>
+  hasSeason_id_Season!: Sequelize.BelongsToManyHasAssociationMixin<SeasonModel, SeasonId>
+  hasSeason_id_Seasons!: Sequelize.BelongsToManyHasAssociationsMixin<SeasonModel, SeasonId>
+  countSeason_id_Seasons!: Sequelize.BelongsToManyCountAssociationsMixin
+  // Team hasMany SeasonTeams via team_id
+  Season!: 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
+
+  static initModel (sequelize: Sequelize.Sequelize): typeof TeamModel {
+    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'
+        }
+      },
+      league_id: {
+        type: DataTypes.UUID,
+        allowNull: false,
+        references: {
+          model: 'League',
+          key: 'league_id'
+        }
+      },
+      name: {
+        type: DataTypes.STRING(50),
+        allowNull: false,
+        unique: true
+      },
+      short_name: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        unique: true
+      },
+      country_id: {
+        type: DataTypes.UUID,
+        allowNull: false,
+        references: {
+          model: 'Country',
+          key: 'country_id'
+        }
+      }
+    }, {
+      sequelize,
+      tableName: 'Team',
+      schema: 'public',
+      timestamps: false,
+      indexes: [
+        {
+          name: 'Team_pk',
+          unique: true,
+          fields: [
+            { name: 'team_id' }
+          ]
+        }
+      ]
+    })
+  }
+}