volleyballsimtypes 0.0.140 → 0.0.142

package/dist/cjs/src/service/event/serve.d.ts

@@ -1,28 +0,0 @@
-import { InPlayEvent, InPlayEventOpts } from './in-play-event';
-import { PerformanceStats, Trait } from '../player';
-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
-}
-interface ServeOpts extends InPlayEventOpts {
-    readonly type: ServeTypeEnum;
-    readonly failure: ServeFailureEnum;
-}
-export declare class Serve extends InPlayEvent {
-    readonly failure: ServeFailureEnum;
-    readonly type: ServeTypeEnum;
-    constructor({ score, player, target, failure, type, eventType, modifier, activeTraits }: ServeOpts);
-    static getScore(stats: PerformanceStats, type: ServeTypeEnum, modifier: number, activeTraits: Trait[]): number;
-    toString(): string;
-}
-export {};

package/dist/cjs/src/service/event/serve.js

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Serve = exports.ServeFailureEnum = exports.ServeTypeEnum = void 0;
-const in_play_event_1 = require("./in-play-event");
-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 = {}));
-class Serve extends in_play_event_1.InPlayEvent {
-    constructor({ score, player, target, failure, type, eventType, modifier, activeTraits }) {
-        super({ score, player, target, eventType, modifier, activeTraits });
-        this.type = type;
-        this.failure = failure;
-    }
-    static getScore(stats, type, modifier, activeTraits) {
-        let score = Serve.calculateScore(stats, 'SERVE', ServeTypeEnum[type]) * modifier;
-        for (const trait of activeTraits) {
-            score *= trait.modifier;
-        }
-        return score;
-    }
-    toString() {
-        return `{"score":${this.score},"player":"${this.player}","target":${this.target},"failure":${this.failure},"type":${this.type},"modifier":${this.modifier},"eventType":${this.eventType},"activeTraits":[${this.activeTraits.map(t => `"${t}"`).join(',')}]}`;
-    }
-}
-exports.Serve = Serve;

package/dist/cjs/src/service/event/set.d.ts

@@ -1,27 +0,0 @@
-import { PerformanceStats, Trait } from '../player';
-import { InPlayEvent, InPlayEventOpts } from './in-play-event';
-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
-}
-interface SetOpts extends InPlayEventOpts {
-    readonly type: SetTypeEnum;
-    readonly failure: SetFailureEnum;
-}
-export declare class Set extends InPlayEvent {
-    readonly failure: SetFailureEnum;
-    readonly type: SetTypeEnum;
-    constructor({ score, player, target, failure, type, eventType, modifier, activeTraits }: SetOpts);
-    static getScore(stats: PerformanceStats, type: SetTypeEnum, modifier: number, activeTraits: Trait[]): number;
-    toString(): string;
-}
-export {};

package/dist/cjs/src/service/event/set.js

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Set = exports.SetFailureEnum = exports.SetTypeEnum = void 0;
-const player_1 = require("../player");
-const in_play_event_1 = require("./in-play-event");
-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 = {}));
-class Set extends in_play_event_1.InPlayEvent {
-    constructor({ score, player, target, failure, type, eventType, modifier, activeTraits }) {
-        super({ score, player, target, eventType, modifier, activeTraits });
-        this.type = type;
-        this.failure = failure;
-    }
-    static getScore(stats, type, modifier, activeTraits) {
-        let score = Set.calculateScore(stats, 'SET', SetTypeEnum[type]) * modifier;
-        for (const trait of activeTraits) {
-            switch (true) {
-                case trait === player_1.Trait.MASTER_MIND: {
-                    score *= player_1.Trait.MASTER_MIND.modifier;
-                    break;
-                }
-                case trait === player_1.Trait.MARKSMAN: {
-                    if ([SetTypeEnum.DUMP, SetTypeEnum.SPIKE].includes(type))
-                        score *= player_1.Trait.MARKSMAN.modifier;
-                    break;
-                }
-            }
-        }
-        return score;
-    }
-    toString() {
-        return `{"score":${this.score},"player":"${this.player}","target":${this.target},"failure":${this.failure},"type":${this.type},"modifier":${this.modifier},"eventType":${this.eventType},"activeTraits":[${this.activeTraits.map(t => `"${t}"`).join(',')}]}`;
-    }
-}
-exports.Set = Set;

package/dist/cjs/src/service/event/spike.d.ts

@@ -1,29 +0,0 @@
-import { InPlayEvent, InPlayEventOpts } from './in-play-event';
-import { Player, Trait } from '../player';
-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
-}
-interface SpikeOpts extends InPlayEventOpts {
-    readonly type: SpikeTypeEnum;
-    readonly failure: SpikeFailureEnum;
-}
-export declare class Spike extends InPlayEvent {
-    readonly failure: SpikeFailureEnum;
-    readonly type: SpikeTypeEnum;
-    constructor({ score, player, target, failure, type, eventType, modifier, activeTraits }: SpikeOpts);
-    static getScore(player: Player, type: SpikeTypeEnum, modifier: number, isBackRow: boolean, activeTraits: Trait[]): number;
-    toString(): string;
-}
-export {};

package/dist/cjs/src/service/event/spike.js

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Spike = exports.SpikeFailureEnum = exports.SpikeTypeEnum = void 0;
-const in_play_event_1 = require("./in-play-event");
-const player_1 = require("../player");
-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 = {}));
-class Spike extends in_play_event_1.InPlayEvent {
-    constructor({ score, player, target, failure, type, eventType, modifier, activeTraits }) {
-        super({ score, player, target, eventType, modifier, activeTraits });
-        this.type = type;
-        this.failure = failure;
-    }
-    static getScore(player, type, modifier, isBackRow, activeTraits) {
-        let score = Spike.calculateScore(player.stats, 'SPIKE', SpikeTypeEnum[type]);
-        if (![SpikeTypeEnum.DOWN_BALL, SpikeTypeEnum.OVERHAND, SpikeTypeEnum.TIP].includes(type) && isBackRow) {
-            score = score * 0.7 + player.stats.backAttack * 0.3;
-        }
-        score *= modifier;
-        for (const trait of activeTraits) {
-            switch (true) {
-                case trait === player_1.Trait.MASTER_MIND: {
-                    score *= player_1.Trait.MASTER_MIND.modifier;
-                    break;
-                }
-                case trait === player_1.Trait.MARKSMAN: {
-                    score *= player_1.Trait.MARKSMAN.modifier;
-                    break;
-                }
-            }
-        }
-        return score;
-    }
-    toString() {
-        return `{"score":${this.score},"player":"${this.player}","target":${this.target},"failure":${this.failure},"type":${this.type},"modifier":${this.modifier},"eventType":${this.eventType},"activeTraits":[${this.activeTraits.map(t => `"${t}"`).join(',')}]}`;
-    }
-}
-exports.Spike = Spike;

package/dist/cjs/src/service/event/substitution.d.ts

@@ -1,11 +0,0 @@
-import { RallyEvent, RallyEventOpts } from './rally-event';
-import { Player } from '../player';
-interface SubstitutionOpts extends RallyEventOpts {
-    readonly playerOut: Player;
-}
-export declare class Substitution extends RallyEvent {
-    readonly playerOut: string;
-    constructor({ playerOut, player, eventType }: SubstitutionOpts);
-    toString(): string;
-}
-export {};

package/dist/cjs/src/service/event/substitution.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Substitution = void 0;
-const rally_event_1 = require("./rally-event");
-class Substitution extends rally_event_1.RallyEvent {
-    constructor({ playerOut, player, eventType }) {
-        super({ eventType, player });
-        this.playerOut = playerOut.id;
-    }
-    toString() {
-        return `{"player":"${this.player}","playerOut":"${this.playerOut}","eventType":${this.eventType}}`;
-    }
-}
-exports.Substitution = Substitution;

package/dist/cjs/src/service/player/player.d.ts

@@ -1,46 +0,0 @@
-import { PerformanceStats } from './performance-stats';
-import { Role } from './role';
-import { Trait } from './trait';
-import { Country } from '../country';
-import { GeneralStat } from './stats';
-export declare class Stat {
-    readonly name: GeneralStat;
-    readonly value: number;
-    constructor({ name, value }: {
-        name: GeneralStat;
-        value: number;
-    });
-    toString(): string;
-}
-interface PlayerParams {
-    readonly id: string;
-    readonly name: Name;
-    readonly country: Country;
-    readonly stats: PerformanceStats;
-    readonly roles: Role[];
-    readonly traits: Trait[];
-}
-export declare class Name {
-    readonly first: string;
-    readonly last: string;
-    constructor({ first, last }: {
-        first: string;
-        last: string;
-    });
-    toString(): string;
-}
-export declare class Player {
-    readonly id: string;
-    readonly name: Name;
-    readonly country: Country;
-    readonly stats: PerformanceStats;
-    readonly roles: Role[];
-    readonly traits: Trait[];
-    readonly generalStats: Stat[];
-    constructor({ id, name, country, stats, roles, traits }: PlayerParams);
-    static sortPlayers(roles: Role[]): (p1: Player, p2: Player) => number;
-    static compareStats(p1: Player, p2: Player): number;
-    canPlayLibero(): boolean;
-    toString(): string;
-}
-export {};

package/dist/cjs/src/service/player/role.js

@@ -1,49 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Role = void 0;
-const role_formula_json_1 = __importDefault(require("../../../data/role.formula.json"));
-class Role {
-    constructor(name) {
-        this.name = name;
-    }
-    toString() {
-        return this.name;
-    }
-    static getRoles() {
-        return [...Role.ROLES];
-    }
-    static calculateScore(stats, role) {
-        const weights = role_formula_json_1.default.find(r => r.role === role.name);
-        if (weights == null)
-            throw new Error('COULD_NOT_FIND_ROLE_WEIGHT');
-        const score = Object.entries(weights.weight)
-            .reduce((score, [key, value]) => score + (stats[key] * weights.weight[key]), 0);
-        return Math.round(score);
-    }
-    static assignRoles(stats) {
-        const scores = this.getRoles().map(role => ({
-            role,
-            score: this.calculateScore(stats, role)
-        })).sort((x, y) => y.score - x.score);
-        const out = [scores[0].role];
-        if (scores[1].score >= 75) {
-            out.push(scores[1].role);
-        }
-        if (scores[2].score >= 85) {
-            out.push(scores[2].role);
-        }
-        return out;
-    }
-}
-exports.Role = Role;
-Role.SETTER = new Role('SETTER');
-Role.LIBERO = new Role('LIBERO');
-Role.OUTSIDE_HITTER = new Role('OUTSIDE_HITTER');
-Role.OPPOSITE_HITTER = new Role('OPPOSITE_HITTER');
-Role.MIDDLE_BLOCKER = new Role('MIDDLE_BLOCKER');
-Role.DEFENSIVE_SPECIALIST = new Role('DEFENSIVE_SPECIALIST');
-Role.ROLES = [Role.LIBERO, Role.SETTER, Role.OPPOSITE_HITTER, Role.OUTSIDE_HITTER, Role.MIDDLE_BLOCKER,
-    Role.DEFENSIVE_SPECIALIST];

package/dist/cjs/src/service/player/stats.d.ts

@@ -1,11 +0,0 @@
-import { PerformanceStats } from './performance-stats';
-export declare enum GeneralStat {
-    ATTACK = "ATTACK",
-    DEFENSE = "DEFENSE",
-    SERVE = "SERVE",
-    PHYSICAL = "PHYSICAL"
-}
-export declare namespace GeneralStat {
-    function getStats(): GeneralStat[];
-    function calculateScore(performanceStats: PerformanceStats, statName: GeneralStat): number;
-}

package/dist/cjs/src/service/player/stats.js

@@ -1,31 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GeneralStat = void 0;
-const stat_formula_json_1 = __importDefault(require("../../../data/stat.formula.json"));
-var GeneralStat;
-(function (GeneralStat) {
-    GeneralStat["ATTACK"] = "ATTACK";
-    GeneralStat["DEFENSE"] = "DEFENSE";
-    GeneralStat["SERVE"] = "SERVE";
-    GeneralStat["PHYSICAL"] = "PHYSICAL";
-})(GeneralStat = exports.GeneralStat || (exports.GeneralStat = {}));
-// eslint-disable-next-line @typescript-eslint/no-namespace
-(function (GeneralStat) {
-    const STATS = [GeneralStat.ATTACK, GeneralStat.DEFENSE, GeneralStat.SERVE, GeneralStat.PHYSICAL];
-    function getStats() {
-        return [...STATS];
-    }
-    GeneralStat.getStats = getStats;
-    function calculateScore(performanceStats, statName) {
-        const weights = stat_formula_json_1.default.find(s => s.statName === statName);
-        if (weights == null)
-            throw new Error('COULD_NOT_FIND_ROLE_WEIGHT');
-        const score = Object.entries(weights.weight)
-            .reduce((score, [key, value]) => score + (performanceStats[key] * value), 0);
-        return Math.round(score);
-    }
-    GeneralStat.calculateScore = calculateScore;
-})(GeneralStat = exports.GeneralStat || (exports.GeneralStat = {}));

package/dist/esm/service/player/stats.d.ts

@@ -1,11 +0,0 @@
-import { PerformanceStats } from './performance-stats';
-export declare enum GeneralStat {
-    ATTACK = "ATTACK",
-    DEFENSE = "DEFENSE",
-    SERVE = "SERVE",
-    PHYSICAL = "PHYSICAL"
-}
-export declare namespace GeneralStat {
-    function getStats(): GeneralStat[];
-    function calculateScore(performanceStats: PerformanceStats, statName: GeneralStat): number;
-}

package/dist/esm/service/player/stats.js

@@ -1,25 +0,0 @@
-import stats from '../../../data/stat.formula.json';
-export var GeneralStat;
-(function (GeneralStat) {
-    GeneralStat["ATTACK"] = "ATTACK";
-    GeneralStat["DEFENSE"] = "DEFENSE";
-    GeneralStat["SERVE"] = "SERVE";
-    GeneralStat["PHYSICAL"] = "PHYSICAL";
-})(GeneralStat || (GeneralStat = {}));
-// eslint-disable-next-line @typescript-eslint/no-namespace
-(function (GeneralStat) {
-    const STATS = [GeneralStat.ATTACK, GeneralStat.DEFENSE, GeneralStat.SERVE, GeneralStat.PHYSICAL];
-    function getStats() {
-        return [...STATS];
-    }
-    GeneralStat.getStats = getStats;
-    function calculateScore(performanceStats, statName) {
-        const weights = stats.find(s => s.statName === statName);
-        if (weights == null)
-            throw new Error('COULD_NOT_FIND_ROLE_WEIGHT');
-        const score = Object.entries(weights.weight)
-            .reduce((score, [key, value]) => score + (performanceStats[key] * value), 0);
-        return Math.round(score);
-    }
-    GeneralStat.calculateScore = calculateScore;
-})(GeneralStat || (GeneralStat = {}));

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

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

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

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

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

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

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

@@ -1,194 +0,0 @@
-import { CoachModel, CompetitionChampionModel, CompetitionMatchModel, CompetitionModel, CompetitionTeamsModel, CountryModel, DraftModel, DraftPickModel, IterationModel, LeagueModel, LeagueSeasonModel, MatchModel, MatchRatingModel, MatchSetModel, MatchSetStatsModel, PerformanceStatsModel, PlayerModel, PlayerTeamModel, PlayerTraitModel, RallyModel, SetPositionModel, TeamModel, TraitModel, UserModel } from './models';
-export function initModels(sequelize) {
-    const Coach = CoachModel.initModel(sequelize);
-    const Country = CountryModel.initModel(sequelize);
-    const Competition = CompetitionModel.initModel(sequelize);
-    const CompetitionTeams = CompetitionTeamsModel.initModel(sequelize);
-    const CompetitionChampion = CompetitionChampionModel.initModel(sequelize);
-    const CompetitionMatch = CompetitionMatchModel.initModel(sequelize);
-    const Draft = DraftModel.initModel(sequelize);
-    const DraftPick = DraftPickModel.initModel(sequelize);
-    const Iteration = IterationModel.initModel(sequelize);
-    const League = LeagueModel.initModel(sequelize);
-    const LeagueSeason = LeagueSeasonModel.initModel(sequelize);
-    const Match = MatchModel.initModel(sequelize);
-    const MatchRating = MatchRatingModel.initModel(sequelize);
-    const MatchSet = MatchSetModel.initModel(sequelize);
-    const MatchSetStats = MatchSetStatsModel.initModel(sequelize);
-    const PerformanceStats = PerformanceStatsModel.initModel(sequelize);
-    const Player = PlayerModel.initModel(sequelize);
-    const PlayerTeam = PlayerTeamModel.initModel(sequelize);
-    const PlayerTrait = PlayerTraitModel.initModel(sequelize);
-    const Rally = RallyModel.initModel(sequelize);
-    const SetPosition = SetPositionModel.initModel(sequelize);
-    const Team = TeamModel.initModel(sequelize);
-    const Trait = TraitModel.initModel(sequelize);
-    const User = 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' });
-    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' });
-    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,
-        MatchSet,
-        MatchSetStats,
-        PerformanceStats,
-        Player,
-        PlayerTeam,
-        PlayerTrait,
-        Rally,
-        SetPosition,
-        Team,
-        Trait,
-        User
-    };
-}