volleyballsimtypes 0.0.7 → 0.0.8

package/src/data/models/serve.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 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

@@ -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 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

@@ -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 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

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

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