volleyballsimtypes 0.0.162 → 0.0.165

package/dist/cjs/src/data/common/events.d.ts

@@ -0,0 +1,82 @@
+export declare enum EventTypeEnum {
+    LIBERO_REPLACEMENT = 0,
+    SUBSTITUTION = 1,
+    SERVE = 2,
+    RECEPTION = 3,
+    SET = 4,
+    SPIKE = 5,
+    BLOCK = 6
+}
+export declare enum BlockFailureEnum {
+    NO_FAILURE = 0,
+    MISS = 1,
+    FAULT = 2,
+    OUT_OF_BOUNDS = 3,
+    WIPE = 4,
+    TOOL = 5
+}
+export declare enum BlockTypeEnum {
+    NO_BLOCKER = 0,
+    SINGLE = 1,
+    DOUBLE = 2,
+    TRIPLE = 3
+}
+export declare enum LiberoReplacementTypeEnum {
+    LIBERO_IN = 0,
+    LIBERO_OUT = 1
+}
+export declare enum ReceptionTypeEnum {
+    DIG = 0,
+    OVERHAND = 1,
+    ONE_HAND = 2,
+    OTHER_BODY_PART = 3
+}
+export declare enum ReceptionFailureEnum {
+    NO_FAILURE = 0,
+    FAULT = 1,
+    MISS = 2,
+    OUT_OF_BOUNDS = 3,
+    BAD_PASS = 4
+}
+export declare enum ServeTypeEnum {
+    UNDERHAND = 0,
+    OVERHAND_TOPSPIN = 1,
+    OVERHAND_FLOAT = 2,
+    JUMP_TOPSPIN = 3,
+    JUMP_FLOAT = 4
+}
+export declare enum ServeFailureEnum {
+    NO_FAILURE = 0,
+    FAULT = 1,
+    MISS = 2,
+    NET = 3,
+    OUT_OF_BOUNDS = 4
+}
+export declare enum SetTypeEnum {
+    OVERHAND = 0,
+    UNDERHAND = 1,
+    SPIKE = 2,
+    DUMP = 3
+}
+export declare enum SetFailureEnum {
+    NO_FAILURE = 0,
+    FAULT = 1,
+    MISS = 2,
+    BAD_PASS = 3,
+    OUT_OF_BOUNDS = 4
+}
+export declare enum SpikeTypeEnum {
+    CROSS_SHOT = 0,
+    LINE_SHOT = 1,
+    TOOL_SHOT = 2,
+    TIP = 3,
+    DOWN_BALL = 4,
+    OVERHAND = 5
+}
+export declare enum SpikeFailureEnum {
+    NO_FAILURE = 0,
+    FAULT = 1,
+    MISS = 2,
+    OUT_OF_BOUNDS = 3,
+    NET = 4
+}

package/dist/cjs/src/data/common/events.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpikeFailureEnum = exports.SpikeTypeEnum = exports.SetFailureEnum = exports.SetTypeEnum = exports.ServeFailureEnum = exports.ServeTypeEnum = exports.ReceptionFailureEnum = exports.ReceptionTypeEnum = exports.LiberoReplacementTypeEnum = exports.BlockTypeEnum = exports.BlockFailureEnum = exports.EventTypeEnum = void 0;
+var EventTypeEnum;
+(function (EventTypeEnum) {
+    EventTypeEnum[EventTypeEnum["LIBERO_REPLACEMENT"] = 0] = "LIBERO_REPLACEMENT";
+    EventTypeEnum[EventTypeEnum["SUBSTITUTION"] = 1] = "SUBSTITUTION";
+    EventTypeEnum[EventTypeEnum["SERVE"] = 2] = "SERVE";
+    EventTypeEnum[EventTypeEnum["RECEPTION"] = 3] = "RECEPTION";
+    EventTypeEnum[EventTypeEnum["SET"] = 4] = "SET";
+    EventTypeEnum[EventTypeEnum["SPIKE"] = 5] = "SPIKE";
+    EventTypeEnum[EventTypeEnum["BLOCK"] = 6] = "BLOCK";
+})(EventTypeEnum = exports.EventTypeEnum || (exports.EventTypeEnum = {}));
+var BlockFailureEnum;
+(function (BlockFailureEnum) {
+    BlockFailureEnum[BlockFailureEnum["NO_FAILURE"] = 0] = "NO_FAILURE";
+    BlockFailureEnum[BlockFailureEnum["MISS"] = 1] = "MISS";
+    BlockFailureEnum[BlockFailureEnum["FAULT"] = 2] = "FAULT";
+    BlockFailureEnum[BlockFailureEnum["OUT_OF_BOUNDS"] = 3] = "OUT_OF_BOUNDS";
+    BlockFailureEnum[BlockFailureEnum["WIPE"] = 4] = "WIPE";
+    BlockFailureEnum[BlockFailureEnum["TOOL"] = 5] = "TOOL";
+})(BlockFailureEnum = exports.BlockFailureEnum || (exports.BlockFailureEnum = {}));
+var BlockTypeEnum;
+(function (BlockTypeEnum) {
+    BlockTypeEnum[BlockTypeEnum["NO_BLOCKER"] = 0] = "NO_BLOCKER";
+    BlockTypeEnum[BlockTypeEnum["SINGLE"] = 1] = "SINGLE";
+    BlockTypeEnum[BlockTypeEnum["DOUBLE"] = 2] = "DOUBLE";
+    BlockTypeEnum[BlockTypeEnum["TRIPLE"] = 3] = "TRIPLE";
+})(BlockTypeEnum = exports.BlockTypeEnum || (exports.BlockTypeEnum = {}));
+var LiberoReplacementTypeEnum;
+(function (LiberoReplacementTypeEnum) {
+    LiberoReplacementTypeEnum[LiberoReplacementTypeEnum["LIBERO_IN"] = 0] = "LIBERO_IN";
+    LiberoReplacementTypeEnum[LiberoReplacementTypeEnum["LIBERO_OUT"] = 1] = "LIBERO_OUT";
+})(LiberoReplacementTypeEnum = exports.LiberoReplacementTypeEnum || (exports.LiberoReplacementTypeEnum = {}));
+var ReceptionTypeEnum;
+(function (ReceptionTypeEnum) {
+    ReceptionTypeEnum[ReceptionTypeEnum["DIG"] = 0] = "DIG";
+    ReceptionTypeEnum[ReceptionTypeEnum["OVERHAND"] = 1] = "OVERHAND";
+    ReceptionTypeEnum[ReceptionTypeEnum["ONE_HAND"] = 2] = "ONE_HAND";
+    ReceptionTypeEnum[ReceptionTypeEnum["OTHER_BODY_PART"] = 3] = "OTHER_BODY_PART";
+})(ReceptionTypeEnum = exports.ReceptionTypeEnum || (exports.ReceptionTypeEnum = {}));
+var ReceptionFailureEnum;
+(function (ReceptionFailureEnum) {
+    ReceptionFailureEnum[ReceptionFailureEnum["NO_FAILURE"] = 0] = "NO_FAILURE";
+    ReceptionFailureEnum[ReceptionFailureEnum["FAULT"] = 1] = "FAULT";
+    ReceptionFailureEnum[ReceptionFailureEnum["MISS"] = 2] = "MISS";
+    ReceptionFailureEnum[ReceptionFailureEnum["OUT_OF_BOUNDS"] = 3] = "OUT_OF_BOUNDS";
+    ReceptionFailureEnum[ReceptionFailureEnum["BAD_PASS"] = 4] = "BAD_PASS";
+})(ReceptionFailureEnum = exports.ReceptionFailureEnum || (exports.ReceptionFailureEnum = {}));
+var ServeTypeEnum;
+(function (ServeTypeEnum) {
+    ServeTypeEnum[ServeTypeEnum["UNDERHAND"] = 0] = "UNDERHAND";
+    ServeTypeEnum[ServeTypeEnum["OVERHAND_TOPSPIN"] = 1] = "OVERHAND_TOPSPIN";
+    ServeTypeEnum[ServeTypeEnum["OVERHAND_FLOAT"] = 2] = "OVERHAND_FLOAT";
+    ServeTypeEnum[ServeTypeEnum["JUMP_TOPSPIN"] = 3] = "JUMP_TOPSPIN";
+    ServeTypeEnum[ServeTypeEnum["JUMP_FLOAT"] = 4] = "JUMP_FLOAT";
+})(ServeTypeEnum = exports.ServeTypeEnum || (exports.ServeTypeEnum = {}));
+var ServeFailureEnum;
+(function (ServeFailureEnum) {
+    ServeFailureEnum[ServeFailureEnum["NO_FAILURE"] = 0] = "NO_FAILURE";
+    ServeFailureEnum[ServeFailureEnum["FAULT"] = 1] = "FAULT";
+    ServeFailureEnum[ServeFailureEnum["MISS"] = 2] = "MISS";
+    ServeFailureEnum[ServeFailureEnum["NET"] = 3] = "NET";
+    ServeFailureEnum[ServeFailureEnum["OUT_OF_BOUNDS"] = 4] = "OUT_OF_BOUNDS";
+})(ServeFailureEnum = exports.ServeFailureEnum || (exports.ServeFailureEnum = {}));
+var SetTypeEnum;
+(function (SetTypeEnum) {
+    SetTypeEnum[SetTypeEnum["OVERHAND"] = 0] = "OVERHAND";
+    SetTypeEnum[SetTypeEnum["UNDERHAND"] = 1] = "UNDERHAND";
+    SetTypeEnum[SetTypeEnum["SPIKE"] = 2] = "SPIKE";
+    SetTypeEnum[SetTypeEnum["DUMP"] = 3] = "DUMP";
+})(SetTypeEnum = exports.SetTypeEnum || (exports.SetTypeEnum = {}));
+var SetFailureEnum;
+(function (SetFailureEnum) {
+    SetFailureEnum[SetFailureEnum["NO_FAILURE"] = 0] = "NO_FAILURE";
+    SetFailureEnum[SetFailureEnum["FAULT"] = 1] = "FAULT";
+    SetFailureEnum[SetFailureEnum["MISS"] = 2] = "MISS";
+    SetFailureEnum[SetFailureEnum["BAD_PASS"] = 3] = "BAD_PASS";
+    SetFailureEnum[SetFailureEnum["OUT_OF_BOUNDS"] = 4] = "OUT_OF_BOUNDS";
+})(SetFailureEnum = exports.SetFailureEnum || (exports.SetFailureEnum = {}));
+var SpikeTypeEnum;
+(function (SpikeTypeEnum) {
+    SpikeTypeEnum[SpikeTypeEnum["CROSS_SHOT"] = 0] = "CROSS_SHOT";
+    SpikeTypeEnum[SpikeTypeEnum["LINE_SHOT"] = 1] = "LINE_SHOT";
+    SpikeTypeEnum[SpikeTypeEnum["TOOL_SHOT"] = 2] = "TOOL_SHOT";
+    SpikeTypeEnum[SpikeTypeEnum["TIP"] = 3] = "TIP";
+    SpikeTypeEnum[SpikeTypeEnum["DOWN_BALL"] = 4] = "DOWN_BALL";
+    SpikeTypeEnum[SpikeTypeEnum["OVERHAND"] = 5] = "OVERHAND";
+})(SpikeTypeEnum = exports.SpikeTypeEnum || (exports.SpikeTypeEnum = {}));
+var SpikeFailureEnum;
+(function (SpikeFailureEnum) {
+    SpikeFailureEnum[SpikeFailureEnum["NO_FAILURE"] = 0] = "NO_FAILURE";
+    SpikeFailureEnum[SpikeFailureEnum["FAULT"] = 1] = "FAULT";
+    SpikeFailureEnum[SpikeFailureEnum["MISS"] = 2] = "MISS";
+    SpikeFailureEnum[SpikeFailureEnum["OUT_OF_BOUNDS"] = 3] = "OUT_OF_BOUNDS";
+    SpikeFailureEnum[SpikeFailureEnum["NET"] = 4] = "NET";
+})(SpikeFailureEnum = exports.SpikeFailureEnum || (exports.SpikeFailureEnum = {}));

package/dist/cjs/src/data/common/index.d.ts

@@ -0,0 +1,2 @@
+export * from './status';
+export * from './events';

package/dist/cjs/src/data/common/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./status"), exports);
+__exportStar(require("./events"), exports);

package/dist/cjs/src/data/common/status.d.ts

@@ -0,0 +1,8 @@
+import { EnumDataType } from 'sequelize';
+export declare enum StatusEnum {
+    PENDING = "PENDING",
+    IN_PROGRESS = "IN_PROGRESS",
+    COMPLETE = "COMPLETE"
+}
+export type Status = StatusEnum.PENDING | StatusEnum.IN_PROGRESS | StatusEnum.COMPLETE;
+export declare const StatusDataType: EnumDataType<Status>;

package/dist/cjs/src/data/common/status.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatusDataType = exports.StatusEnum = void 0;
+const sequelize_1 = require("sequelize");
+var StatusEnum;
+(function (StatusEnum) {
+    StatusEnum["PENDING"] = "PENDING";
+    StatusEnum["IN_PROGRESS"] = "IN_PROGRESS";
+    StatusEnum["COMPLETE"] = "COMPLETE";
+})(StatusEnum = exports.StatusEnum || (exports.StatusEnum = {}));
+exports.StatusDataType = sequelize_1.DataTypes.ENUM(...Object.values(StatusEnum));

package/dist/cjs/src/data/index.d.ts

@@ -0,0 +1,4 @@
+export * from './models';
+export * from './transformers';
+export * from './common';
+export { initModels } from './init-models';

package/dist/cjs/src/data/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initModels = void 0;
+__exportStar(require("./models"), exports);
+__exportStar(require("./transformers"), exports);
+__exportStar(require("./common"), exports);
+var init_models_1 = require("./init-models");
+Object.defineProperty(exports, "initModels", { enumerable: true, get: function () { return init_models_1.initModels; } });

package/dist/cjs/src/data/init-models.d.ts

@@ -0,0 +1,2 @@
+import type { Sequelize } from 'sequelize';
+export declare function initModels(sequelize: Sequelize): any;

package/dist/cjs/src/data/init-models.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initModels = void 0;
+const models_1 = require("./models");
+function initModels(sequelize) {
+    const Coach = models_1.CoachModel.initModel(sequelize);
+    const Country = models_1.CountryModel.initModel(sequelize);
+    const Competition = models_1.CompetitionModel.initModel(sequelize);
+    const CompetitionTeams = models_1.CompetitionTeamsModel.initModel(sequelize);
+    const CompetitionChampion = models_1.CompetitionChampionModel.initModel(sequelize);
+    const CompetitionMatch = models_1.CompetitionMatchModel.initModel(sequelize);
+    const Draft = models_1.DraftModel.initModel(sequelize);
+    const DraftPick = models_1.DraftPickModel.initModel(sequelize);
+    const Iteration = models_1.IterationModel.initModel(sequelize);
+    const League = models_1.LeagueModel.initModel(sequelize);
+    const LeagueSeason = models_1.LeagueSeasonModel.initModel(sequelize);
+    const Match = models_1.MatchModel.initModel(sequelize);
+    const MatchRating = models_1.MatchRatingModel.initModel(sequelize);
+    const MatchResult = models_1.MatchResultModel.initModel(sequelize);
+    const MatchSet = models_1.MatchSetModel.initModel(sequelize);
+    const MatchSetStats = models_1.MatchSetStatsModel.initModel(sequelize);
+    const PerformanceStats = models_1.PerformanceStatsModel.initModel(sequelize);
+    const Player = models_1.PlayerModel.initModel(sequelize);
+    const PlayerTeam = models_1.PlayerTeamModel.initModel(sequelize);
+    const PlayerTrait = models_1.PlayerTraitModel.initModel(sequelize);
+    const Rally = models_1.RallyModel.initModel(sequelize);
+    const SetPosition = models_1.SetPositionModel.initModel(sequelize);
+    const Team = models_1.TeamModel.initModel(sequelize);
+    const Trait = models_1.TraitModel.initModel(sequelize);
+    const User = models_1.UserModel.initModel(sequelize);
+    Coach.belongsTo(Country, { as: 'country', foreignKey: 'country_id' });
+    Coach.hasMany(Team, { as: 'Teams', foreignKey: 'coach_id' });
+    Competition.belongsTo(Iteration, { as: 'Iteration', foreignKey: 'iteration' });
+    Competition.hasMany(CompetitionMatch, { as: 'CompetitionMatches', foreignKey: 'competition_id' });
+    Competition.hasMany(CompetitionTeams, { as: 'CompetitionTeams', foreignKey: 'competition_id' });
+    Competition.hasOne(CompetitionChampion, { as: 'CompetitionChampion', foreignKey: 'competition_id' });
+    Competition.hasOne(LeagueSeason, { as: 'LeagueSeason', foreignKey: 'competition_id' });
+    Competition.belongsToMany(Team, {
+        as: 'Teams',
+        through: CompetitionTeams,
+        foreignKey: 'competition_id',
+        otherKey: 'team_id'
+    });
+    CompetitionChampion.belongsTo(Competition, { as: 'competition', foreignKey: 'competition_id' });
+    CompetitionChampion.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
+    CompetitionMatch.belongsTo(Competition, { as: 'Competition', foreignKey: 'competition_id' });
+    CompetitionMatch.belongsTo(Match, { as: 'Match', foreignKey: 'match_id' });
+    CompetitionTeams.belongsTo(Competition, { as: 'competition', foreignKey: 'competition_id' });
+    CompetitionTeams.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
+    Country.hasMany(Coach, { as: 'Coaches', foreignKey: 'country_id' });
+    Country.hasMany(League, { as: 'Leagues', foreignKey: 'country_id' });
+    Country.hasMany(Player, { as: 'Players', foreignKey: 'country_id' });
+    Country.hasMany(Team, { as: 'Teams', foreignKey: 'country_id' });
+    Draft.hasMany(DraftPick, { as: 'DraftPicks', foreignKey: 'draft_id' });
+    DraftPick.belongsTo(Draft, { as: 'draft', foreignKey: 'draft_id' });
+    DraftPick.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
+    DraftPick.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
+    Iteration.hasMany(Competition, { as: 'Competitions', foreignKey: 'iteration' });
+    League.belongsTo(Country, { as: 'country', foreignKey: 'country_id' });
+    League.hasMany(LeagueSeason, { as: 'LeagueSeasons', foreignKey: 'league_id' });
+    League.hasMany(Team, { as: 'Teams', foreignKey: 'league_id' });
+    LeagueSeason.belongsTo(Competition, { as: 'competition', foreignKey: 'competition_id' });
+    LeagueSeason.belongsTo(League, { as: 'league', foreignKey: 'league_id' });
+    Match.belongsTo(Team, { as: 'AwayTeam', foreignKey: 'away_team' });
+    Match.belongsTo(Team, { as: 'HomeTeam', foreignKey: 'home_team' });
+    Match.belongsToMany(Team, {
+        as: 'TeamMatchRatings',
+        through: MatchRating,
+        foreignKey: 'match_id',
+        otherKey: 'team_id'
+    });
+    Match.hasMany(MatchRating, { as: 'MatchRatings', foreignKey: 'match_id' });
+    Match.hasMany(MatchSet, { as: 'MatchSets', foreignKey: 'match_id' });
+    Match.hasOne(CompetitionMatch, { as: 'CompetitionMatch', foreignKey: 'match_id' });
+    Match.hasOne(MatchResult, { as: 'MatchResult', foreignKey: 'match_id' });
+    MatchResult.belongsTo(Match, { as: 'Match', foreignKey: 'match_id' });
+    MatchResult.belongsTo(Team, { as: 'WinnerTeam', foreignKey: 'winner_team_id' });
+    MatchRating.belongsTo(Match, { as: 'match', foreignKey: 'match_id' });
+    MatchRating.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
+    MatchSet.belongsTo(Match, { as: 'match', foreignKey: 'match_id' });
+    MatchSet.belongsToMany(Player, {
+        as: 'SetPositionsPlayer',
+        through: SetPosition,
+        foreignKey: 'match_set_id',
+        otherKey: 'player_id'
+    });
+    MatchSet.belongsToMany(Player, {
+        as: 'SetStatsPlayers',
+        through: MatchSetStats,
+        foreignKey: 'match_set_id',
+        otherKey: 'player_id'
+    });
+    MatchSet.hasMany(MatchSetStats, { as: 'MatchSetStats', foreignKey: 'match_set_id' });
+    MatchSet.hasMany(Rally, { as: 'Rallies', foreignKey: 'match_set_id' });
+    MatchSet.hasMany(SetPosition, { as: 'SetPositions', foreignKey: 'match_set_id' });
+    MatchSetStats.belongsTo(MatchSet, { as: 'matchSet', foreignKey: 'match_set_id' });
+    MatchSetStats.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
+    PerformanceStats.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
+    Player.belongsTo(Country, { as: 'country', foreignKey: 'country_id' });
+    Player.belongsToMany(MatchSet, {
+        as: 'SetPositionSets',
+        through: SetPosition,
+        foreignKey: 'player_id',
+        otherKey: 'match_set_id'
+    });
+    Player.belongsToMany(MatchSet, {
+        as: 'StatsMatchSets',
+        through: MatchSetStats,
+        foreignKey: 'player_id',
+        otherKey: 'match_set_id'
+    });
+    Player.belongsToMany(Team, {
+        as: 'Teams',
+        through: PlayerTeam,
+        foreignKey: 'player_id',
+        otherKey: 'team_id'
+    });
+    Player.belongsToMany(Trait, {
+        as: 'Traits',
+        through: PlayerTrait,
+        foreignKey: 'player_id',
+        otherKey: 'trait_id'
+    });
+    Player.hasMany(MatchSetStats, { as: 'MatchSetStats', foreignKey: 'player_id' });
+    Player.hasMany(PlayerTeam, { as: 'PlayerTeams', foreignKey: 'player_id' });
+    Player.hasMany(PlayerTrait, { as: 'PlayerTraits', foreignKey: 'player_id' });
+    Player.hasMany(SetPosition, { as: 'SetPositions', foreignKey: 'player_id' });
+    Player.hasOne(DraftPick, { as: 'DraftPick', foreignKey: 'player_id' });
+    Player.hasOne(PerformanceStats, { as: 'PerformanceStat', foreignKey: 'player_id' });
+    PlayerTeam.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
+    PlayerTeam.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
+    PlayerTrait.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
+    PlayerTrait.belongsTo(Trait, { as: 'trait', foreignKey: 'trait_id' });
+    Rally.belongsTo(MatchSet, { as: 'matchSet', foreignKey: 'match_set_id' });
+    Rally.belongsTo(Team, { as: 'ServingTeam', foreignKey: 'serving_team' });
+    SetPosition.belongsTo(MatchSet, { as: 'matchSet', foreignKey: 'match_set_id' });
+    SetPosition.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
+    Team.belongsTo(Coach, { as: 'coach', foreignKey: 'coach_id' });
+    Team.belongsTo(Country, { as: 'country', foreignKey: 'country_id' });
+    Team.belongsTo(League, { as: 'league', foreignKey: 'league_id' });
+    Team.belongsToMany(Competition, {
+        as: 'Competitions',
+        through: CompetitionTeams,
+        foreignKey: 'team_id',
+        otherKey: 'competition_id'
+    });
+    Team.belongsToMany(Match, {
+        as: 'RatingMatches',
+        through: MatchRating,
+        foreignKey: 'team_id',
+        otherKey: 'match_id'
+    });
+    Team.belongsToMany(Player, {
+        as: 'Players',
+        through: PlayerTeam,
+        foreignKey: 'team_id',
+        otherKey: 'player_id'
+    });
+    Team.hasMany(CompetitionChampion, { as: 'CompetitionChampions', foreignKey: 'team_id' });
+    Team.hasMany(CompetitionTeams, { as: 'CompetitionTeams', foreignKey: 'team_id' });
+    Team.hasMany(DraftPick, { as: 'DraftPicks', foreignKey: 'team_id' });
+    Team.hasMany(Match, { as: 'HomeMatches', foreignKey: 'home_team' });
+    Team.hasMany(Match, { as: 'AwayMatches', foreignKey: 'away_team' });
+    Team.hasMany(MatchRating, { as: 'MatchRatings', foreignKey: 'team_id' });
+    Team.hasMany(PlayerTeam, { as: 'PlayerTeams', foreignKey: 'team_id' });
+    Team.hasMany(Rally, { as: 'Rallies', foreignKey: 'serving_team' });
+    Team.hasMany(MatchResult, { as: 'WonMatches', foreignKey: 'winner_team_id' });
+    Trait.belongsToMany(Player, {
+        as: 'Players',
+        through: PlayerTrait,
+        foreignKey: 'trait_id',
+        otherKey: 'player_id'
+    });
+    Trait.hasMany(PlayerTrait, { as: 'PlayerTraits', foreignKey: 'trait_id' });
+    return {
+        Coach,
+        Competition,
+        CompetitionChampion,
+        CompetitionMatch,
+        CompetitionTeams,
+        Country,
+        Draft,
+        DraftPick,
+        Event,
+        Iteration,
+        League,
+        LeagueSeason,
+        Match,
+        MatchRating,
+        MatchResult,
+        MatchSet,
+        MatchSetStats,
+        PerformanceStats,
+        Player,
+        PlayerTeam,
+        PlayerTrait,
+        Rally,
+        SetPosition,
+        Team,
+        Trait,
+        User
+    };
+}
+exports.initModels = initModels;

package/dist/cjs/src/data/models/coach.d.ts

@@ -0,0 +1,40 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import { CountryId, CountryModel, TeamId, TeamModel } from '.';
+export interface CoachAttributes {
+    coach_id: string;
+    formation: FormationType;
+    substitution_tolerance: number;
+    first_name: string;
+    last_name: string;
+    country_id: string;
+}
+export type FormationType = '4-2' | '5-1' | '6-2';
+export type CoachPk = 'coach_id';
+export type CoachId = CoachModel[CoachPk];
+export type CoachOptionalAttributes = 'substitution_tolerance';
+export type CoachCreationAttributes = Optional<CoachAttributes, CoachOptionalAttributes>;
+export declare class CoachModel extends Model<CoachAttributes, CoachCreationAttributes> implements CoachAttributes {
+    coach_id: string;
+    formation: FormationType;
+    substitution_tolerance: number;
+    first_name: string;
+    last_name: string;
+    country_id: string;
+    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;
+    country: CountryModel;
+    getCountry: Sequelize.BelongsToGetAssociationMixin<CountryModel>;
+    setCountry: Sequelize.BelongsToSetAssociationMixin<CountryModel, CountryId>;
+    createCountry: Sequelize.BelongsToCreateAssociationMixin<CountryModel>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof CoachModel;
+}

package/dist/cjs/src/data/models/coach.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoachModel = void 0;
+const sequelize_1 = require("sequelize");
+class CoachModel extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return CoachModel.init({
+            coach_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true
+            },
+            formation: {
+                type: sequelize_1.DataTypes.ENUM('4-2', '5-1', '6-2'),
+                allowNull: false
+            },
+            substitution_tolerance: {
+                type: sequelize_1.DataTypes.REAL,
+                allowNull: false,
+                defaultValue: 0
+            },
+            first_name: {
+                type: sequelize_1.DataTypes.STRING,
+                allowNull: false
+            },
+            last_name: {
+                type: sequelize_1.DataTypes.STRING,
+                allowNull: false
+            },
+            country_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'Country',
+                    key: 'country_id'
+                }
+            }
+        }, {
+            sequelize,
+            tableName: 'Coach',
+            schema: 'public',
+            timestamps: false,
+            indexes: [
+                {
+                    name: 'Coach_pk',
+                    unique: true,
+                    fields: [
+                        { name: 'coach_id' }
+                    ]
+                }
+            ]
+        });
+    }
+}
+exports.CoachModel = CoachModel;

package/dist/cjs/src/data/models/competition-champion.d.ts

@@ -0,0 +1,23 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { CompetitionId, CompetitionModel, TeamId, TeamModel } from '.';
+export interface CompetitionChampionAttributes {
+    competition_id: string;
+    team_id: string;
+}
+export type CompetitionChampionPk = 'competition_id';
+export type CompetitionChampionId = CompetitionChampionModel[CompetitionChampionPk];
+export type CompetitionChampionCreationAttributes = CompetitionChampionAttributes;
+export declare class CompetitionChampionModel extends Model<CompetitionChampionAttributes, CompetitionChampionCreationAttributes> implements CompetitionChampionAttributes {
+    competition_id: string;
+    team_id: string;
+    competition: CompetitionModel;
+    getCompetition: Sequelize.BelongsToGetAssociationMixin<CompetitionModel>;
+    setCompetition: Sequelize.BelongsToSetAssociationMixin<CompetitionModel, CompetitionId>;
+    createCompetition: Sequelize.BelongsToCreateAssociationMixin<CompetitionModel>;
+    team: TeamModel;
+    getTeam: Sequelize.BelongsToGetAssociationMixin<TeamModel>;
+    setTeam: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>;
+    createTeam: Sequelize.BelongsToCreateAssociationMixin<TeamModel>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof CompetitionChampionModel;
+}

package/dist/cjs/src/data/models/competition-champion.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompetitionChampionModel = void 0;
+const sequelize_1 = require("sequelize");
+class CompetitionChampionModel extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return CompetitionChampionModel.init({
+            competition_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'Competition',
+                    key: 'competition_id'
+                }
+            },
+            team_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'Team',
+                    key: 'team_id'
+                }
+            }
+        }, {
+            sequelize,
+            tableName: 'CompetitionChampion',
+            schema: 'public',
+            timestamps: false,
+            indexes: [{
+                    name: 'competitionchampion_pk',
+                    unique: true,
+                    fields: [{ name: 'competition_id' }]
+                }]
+        });
+    }
+}
+exports.CompetitionChampionModel = CompetitionChampionModel;

package/dist/cjs/src/data/models/competition-match.d.ts

@@ -0,0 +1,29 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { CompetitionId, CompetitionModel, MatchAttributes, MatchId, MatchModel } from '.';
+export interface CompetitionMatchAttributes {
+    competition_id: string;
+    match_id: string;
+    index: number;
+    stage: CompetitionStage;
+    Match?: MatchAttributes;
+}
+export type CompetitionMatchPk = 'match_id';
+export type CompetitionMatchId = CompetitionMatchModel[CompetitionMatchPk];
+export type CompetitionMatchCreationAttributes = CompetitionMatchAttributes;
+export type CompetitionStage = 'FINAL' | 'LEAGUE' | 'QUARTERFINALS' | 'ROUND_OF_8' | 'SEMIFINALS';
+export declare class CompetitionMatchModel extends Model<CompetitionMatchAttributes, CompetitionMatchCreationAttributes> implements CompetitionMatchAttributes {
+    competition_id: string;
+    match_id: string;
+    index: number;
+    stage: CompetitionStage;
+    Competition: CompetitionModel;
+    getCompetition: Sequelize.BelongsToGetAssociationMixin<CompetitionModel>;
+    setCompetition: Sequelize.BelongsToSetAssociationMixin<CompetitionModel, CompetitionId>;
+    createCompetition: Sequelize.BelongsToCreateAssociationMixin<CompetitionModel>;
+    Match: MatchModel;
+    getMatch: Sequelize.BelongsToGetAssociationMixin<MatchModel>;
+    setMatch: Sequelize.BelongsToSetAssociationMixin<MatchModel, MatchId>;
+    createMatch: Sequelize.BelongsToCreateAssociationMixin<MatchModel>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof CompetitionMatchModel;
+}