volleyballsimtypes 0.0.217 → 0.0.358

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

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

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

@@ -1,22 +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; } });
+"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

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

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

@@ -1,188 +1,265 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.initModels = void 0;
-const models_1 = require("./models");
-function initModels(sequelize) {
-    const Tactics = models_1.TacticsModel.initModel(sequelize);
-    const Country = models_1.CountryModel.initModel(sequelize);
-    const Competition = models_1.CompetitionModel.initModel(sequelize);
-    const CompetitionStandings = models_1.CompetitionStandingsModel.initModel(sequelize);
-    const CompetitionStandingsMatch = models_1.CompetitionStandingsMatchModel.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 Division = models_1.DivisionModel.initModel(sequelize);
-    const DivisionSeason = models_1.DivisionSeasonModel.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 BoxScore = models_1.BoxScoreModel.initModel(sequelize);
-    const BoxScoreTotals = models_1.BoxScoreTotalsModel.initModel(sequelize);
-    const PerformanceStats = models_1.PerformanceStatsModel.initModel(sequelize);
-    const Player = models_1.PlayerModel.initModel(sequelize);
-    const PlayerTeam = models_1.PlayerTeamModel.initModel(sequelize);
-    const Rally = models_1.RallyModel.initModel(sequelize);
-    const Team = models_1.TeamModel.initModel(sequelize);
-    const User = models_1.UserModel.initModel(sequelize);
-    const VPER = models_1.VPERModel.initModel(sequelize);
-    Tactics.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
-    Competition.belongsTo(Iteration, { as: 'Iteration', foreignKey: 'iteration' });
-    Competition.hasMany(CompetitionMatch, { as: 'CompetitionMatches', foreignKey: 'competition_id' });
-    Competition.hasMany(CompetitionStandings, { as: 'CompetitionStandings', foreignKey: 'competition_id' });
-    Competition.hasMany(CompetitionTeams, { as: 'CompetitionTeams', foreignKey: 'competition_id' });
-    Competition.hasOne(CompetitionChampion, { as: 'CompetitionChampion', foreignKey: 'competition_id' });
-    Competition.hasOne(DivisionSeason, { as: 'DivisionSeason', 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(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(Division, { as: 'Divisions', foreignKey: 'league_id' });
-    Division.belongsTo(League, { as: 'league', foreignKey: 'league_id' });
-    Division.hasMany(DivisionSeason, { as: 'DivisionSeasons', foreignKey: 'division_id' });
-    Division.hasMany(Team, { as: 'Teams', foreignKey: 'division_id' });
-    DivisionSeason.belongsTo(Competition, { as: 'competition', foreignKey: 'competition_id' });
-    DivisionSeason.belongsTo(Division, { as: 'division', foreignKey: 'division_id' });
-    CompetitionStandings.belongsTo(Competition, { as: 'Competition', foreignKey: 'competition_id' });
-    CompetitionStandings.belongsTo(Team, { as: 'Team', foreignKey: 'team_id' });
-    CompetitionStandingsMatch.belongsTo(Competition, { as: 'Competition', foreignKey: 'competition_id' });
-    CompetitionStandingsMatch.belongsTo(Match, { as: 'Match', foreignKey: 'match_id' });
-    CompetitionStandingsMatch.belongsTo(Team, { as: 'Team', foreignKey: 'team_id' });
-    Team.belongsTo(Division, { as: 'Division', foreignKey: 'division_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(VPER, { as: 'VPERs', 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: 'Winner', 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: 'BoxScorePlayers',
-        through: BoxScore,
-        foreignKey: 'match_set_id',
-        otherKey: 'player_id'
-    });
-    MatchSet.hasMany(BoxScore, { as: 'BoxScores', foreignKey: 'match_set_id' });
-    MatchSet.hasMany(Rally, { as: 'Rallies', foreignKey: 'match_set_id' });
-    BoxScore.belongsTo(MatchSet, { as: 'MatchSet', foreignKey: 'match_set_id' });
-    BoxScore.belongsTo(Player, { as: 'Player', foreignKey: 'player_id' });
-    BoxScoreTotals.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: 'BoxScoreMatchSets',
-        through: BoxScore,
-        foreignKey: 'player_id',
-        otherKey: 'match_set_id'
-    });
-    Player.belongsToMany(Team, {
-        as: 'Teams',
-        through: PlayerTeam,
-        foreignKey: 'player_id',
-        otherKey: 'team_id'
-    });
-    Player.hasMany(BoxScore, { as: 'BoxScores', foreignKey: 'player_id' });
-    Player.hasMany(VPER, { as: 'VPERs', foreignKey: 'player_id' });
-    Player.hasMany(PlayerTeam, { as: 'PlayerTeams', foreignKey: 'player_id' });
-    Player.hasOne(DraftPick, { as: 'DraftPick', foreignKey: 'player_id' });
-    Player.hasOne(PerformanceStats, { as: 'PerformanceStat', foreignKey: 'player_id' });
-    Player.hasOne(BoxScoreTotals, { as: 'BoxScoreTotals', foreignKey: 'player_id' });
-    PlayerTeam.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
-    PlayerTeam.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
-    Rally.belongsTo(MatchSet, { as: 'matchSet', foreignKey: 'match_set_id' });
-    Rally.belongsTo(Team, { as: 'ServingTeam', foreignKey: 'serving_team' });
-    VPER.belongsTo(Player, { as: 'Player', foreignKey: 'player_id' });
-    VPER.belongsTo(Match, { as: 'Match', foreignKey: 'match_id' });
-    Team.hasOne(Tactics, { as: 'tactics', foreignKey: 'team_id' });
-    Team.belongsTo(Country, { as: 'country', foreignKey: 'country_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' });
-    Team.hasMany(CompetitionStandings, { as: 'CompetitionStandings', foreignKey: 'team_id' });
-    return {
-        Competition,
-        CompetitionChampion,
-        CompetitionMatch,
-        CompetitionStandings,
-        CompetitionStandingsMatch,
-        CompetitionTeams,
-        Country,
-        Division,
-        Draft,
-        DraftPick,
-        Iteration,
-        League,
-        DivisionSeason,
-        Match,
-        MatchRating,
-        MatchResult,
-        MatchSet,
-        BoxScore,
-        BoxScoreTotals,
-        PerformanceStats,
-        Player,
-        PlayerTeam,
-        Rally,
-        Team,
-        Tactics,
-        User,
-        VPER
-    };
-}
-exports.initModels = initModels;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initModels = initModels;
+const models_1 = require("./models");
+function initModels(sequelize) {
+    const Coach = models_1.CoachModel.initModel(sequelize);
+    const CurrencyTransaction = models_1.CurrencyTransactionModel.initModel(sequelize);
+    const Tactics = models_1.TacticsModel.initModel(sequelize);
+    const AuthUser = models_1.AuthUserModel.initModel(sequelize);
+    const UserCurrency = models_1.UserCurrencyModel.initModel(sequelize);
+    const UserPlayerProgress = models_1.UserPlayerProgressModel.initModel(sequelize);
+    const GachaPity = models_1.GachaPityModel.initModel(sequelize);
+    const GachaPullHistory = models_1.GachaPullHistoryModel.initModel(sequelize);
+    const UserPullGrant = models_1.UserPullGrantModel.initModel(sequelize);
+    const Wishlist = models_1.WishlistModel.initModel(sequelize);
+    const UserSettings = models_1.UserSettingsModel.initModel(sequelize);
+    const Notification = models_1.NotificationModel.initModel(sequelize);
+    const AuthIdentity = models_1.AuthIdentityModel.initModel(sequelize);
+    const AuthSession = models_1.AuthSessionModel.initModel(sequelize);
+    const UserTeam = models_1.UserTeamModel.initModel(sequelize);
+    const Country = models_1.CountryModel.initModel(sequelize);
+    const Competition = models_1.CompetitionModel.initModel(sequelize);
+    const CompetitionMVP = models_1.CompetitionMVPModel.initModel(sequelize);
+    const CompetitionStandings = models_1.CompetitionStandingsModel.initModel(sequelize);
+    const CompetitionStandingsMatch = models_1.CompetitionStandingsMatchModel.initModel(sequelize);
+    const CompetitionTeams = models_1.CompetitionTeamsModel.initModel(sequelize);
+    const CompetitionChampion = models_1.CompetitionChampionModel.initModel(sequelize);
+    const CompetitionMatch = models_1.CompetitionMatchModel.initModel(sequelize);
+    const Iteration = models_1.IterationModel.initModel(sequelize);
+    const League = models_1.LeagueModel.initModel(sequelize);
+    const Division = models_1.DivisionModel.initModel(sequelize);
+    const DivisionSeason = models_1.DivisionSeasonModel.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 BoxScore = models_1.BoxScoreModel.initModel(sequelize);
+    const BoxScoreTotals = models_1.BoxScoreTotalsModel.initModel(sequelize);
+    const PerformanceStats = models_1.PerformanceStatsModel.initModel(sequelize);
+    const Player = models_1.PlayerModel.initModel(sequelize);
+    const PlayerImprovementLog = models_1.PlayerImprovementLogModel.initModel(sequelize);
+    const PlayerTeam = models_1.PlayerTeamModel.initModel(sequelize);
+    const Rally = models_1.RallyModel.initModel(sequelize);
+    const PromotionMatch = models_1.PromotionMatchModel.initModel(sequelize);
+    const RegionQualifier = models_1.RegionQualifierModel.initModel(sequelize);
+    const Team = models_1.TeamModel.initModel(sequelize);
+    const TeamReplacement = models_1.TeamReplacementModel.initModel(sequelize);
+    const VPER = models_1.VPERModel.initModel(sequelize);
+    Tactics.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
+    AuthUser.hasMany(AuthIdentity, { as: 'AuthIdentities', foreignKey: 'user_id' });
+    AuthUser.hasMany(AuthSession, { as: 'AuthSessions', foreignKey: 'user_id' });
+    AuthUser.hasOne(UserTeam, { as: 'UserTeam', foreignKey: 'user_id' });
+    AuthUser.hasOne(UserCurrency, { as: 'UserCurrency', foreignKey: 'user_id' });
+    AuthUser.hasMany(CurrencyTransaction, { as: 'CurrencyTransactions', foreignKey: 'user_id' });
+    AuthUser.hasOne(GachaPity, { as: 'GachaPity', foreignKey: 'user_id' });
+    AuthUser.hasOne(Wishlist, { as: 'Wishlist', foreignKey: 'user_id' });
+    AuthUser.hasOne(UserSettings, { as: 'UserSettings', foreignKey: 'user_id' });
+    AuthUser.hasMany(Notification, { as: 'Notifications', foreignKey: 'user_id' });
+    Notification.belongsTo(AuthUser, { as: 'user', foreignKey: 'user_id' });
+    AuthUser.hasMany(GachaPullHistory, { as: 'GachaPullHistory', foreignKey: 'user_id' });
+    AuthUser.hasMany(UserPullGrant, { as: 'UserPullGrants', foreignKey: 'user_id' });
+    AuthIdentity.belongsTo(AuthUser, { as: 'user', foreignKey: 'user_id' });
+    AuthSession.belongsTo(AuthUser, { as: 'user', foreignKey: 'user_id' });
+    UserTeam.belongsTo(AuthUser, { as: 'user', foreignKey: 'user_id' });
+    UserTeam.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
+    UserCurrency.belongsTo(AuthUser, { as: 'user', foreignKey: 'user_id' });
+    CurrencyTransaction.belongsTo(AuthUser, { as: 'user', foreignKey: 'user_id' });
+    GachaPity.belongsTo(AuthUser, { as: 'user', foreignKey: 'user_id' });
+    GachaPullHistory.belongsTo(AuthUser, { as: 'user', foreignKey: 'user_id' });
+    GachaPullHistory.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
+    UserPullGrant.belongsTo(AuthUser, { as: 'user', foreignKey: 'user_id' });
+    Wishlist.belongsTo(AuthUser, { as: 'user', foreignKey: 'user_id' });
+    UserSettings.belongsTo(AuthUser, { as: 'user', foreignKey: 'user_id' });
+    Competition.belongsTo(Iteration, { as: 'Iteration', foreignKey: 'iteration' });
+    Competition.hasMany(CompetitionMatch, { as: 'CompetitionMatches', foreignKey: 'competition_id' });
+    Competition.hasMany(CompetitionStandings, { as: 'CompetitionStandings', foreignKey: 'competition_id' });
+    Competition.hasMany(CompetitionTeams, { as: 'CompetitionTeams', foreignKey: 'competition_id' });
+    Competition.hasOne(CompetitionMVP, { as: 'CompetitionMVP', foreignKey: 'competition_id' });
+    Competition.hasOne(CompetitionChampion, { as: 'CompetitionChampion', foreignKey: 'competition_id' });
+    Competition.hasOne(DivisionSeason, { as: 'DivisionSeason', 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' });
+    CompetitionMVP.belongsTo(Competition, { as: 'competition', foreignKey: 'competition_id' });
+    CompetitionMVP.belongsTo(Player, { as: 'player', foreignKey: 'player_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.hasOne(League, { as: 'League', foreignKey: 'country_id' });
+    Country.hasMany(RegionQualifier, { as: 'RegionQualifiers', foreignKey: 'region_code', sourceKey: 'region_code' });
+    Country.hasMany(Player, { as: 'Players', foreignKey: 'country_id' });
+    Country.hasMany(Team, { as: 'Teams', foreignKey: 'country_id' });
+    Iteration.hasMany(Competition, { as: 'Competitions', foreignKey: 'iteration' });
+    Iteration.hasMany(RegionQualifier, { as: 'RegionQualifiers', foreignKey: 'iteration' });
+    League.belongsTo(Country, { as: 'country', foreignKey: 'country_id' });
+    League.hasMany(Division, { as: 'Divisions', foreignKey: 'league_id' });
+    Division.belongsTo(League, { as: 'league', foreignKey: 'league_id' });
+    Division.hasMany(DivisionSeason, { as: 'DivisionSeasons', foreignKey: 'division_id' });
+    Division.hasMany(Team, { as: 'Teams', foreignKey: 'division_id' });
+    DivisionSeason.belongsTo(Competition, { as: 'competition', foreignKey: 'competition_id' });
+    DivisionSeason.belongsTo(Division, { as: 'division', foreignKey: 'division_id' });
+    CompetitionStandings.belongsTo(Competition, { as: 'Competition', foreignKey: 'competition_id' });
+    CompetitionStandings.belongsTo(Team, { as: 'Team', foreignKey: 'team_id' });
+    CompetitionStandingsMatch.belongsTo(Competition, { as: 'Competition', foreignKey: 'competition_id' });
+    CompetitionStandingsMatch.belongsTo(Match, { as: 'Match', foreignKey: 'match_id' });
+    CompetitionStandingsMatch.belongsTo(Team, { as: 'Team', foreignKey: 'team_id' });
+    Competition.hasMany(PromotionMatch, { as: 'UpperPromotionMatches', foreignKey: 'upper_competition' });
+    Competition.hasMany(PromotionMatch, { as: 'LowerPromotionMatches', foreignKey: 'lower_competition' });
+    Team.belongsTo(Division, { as: 'Division', foreignKey: 'division_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(VPER, { as: 'VPERs', 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: 'Winner', 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: 'BoxScorePlayers',
+        through: BoxScore,
+        foreignKey: 'match_set_id',
+        otherKey: 'player_id'
+    });
+    MatchSet.hasMany(BoxScore, { as: 'BoxScores', foreignKey: 'match_set_id' });
+    MatchSet.hasMany(Rally, { as: 'Rallies', foreignKey: 'match_set_id' });
+    BoxScore.belongsTo(MatchSet, { as: 'MatchSet', foreignKey: 'match_set_id' });
+    BoxScore.belongsTo(Player, { as: 'Player', foreignKey: 'player_id' });
+    BoxScoreTotals.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: 'BoxScoreMatchSets',
+        through: BoxScore,
+        foreignKey: 'player_id',
+        otherKey: 'match_set_id'
+    });
+    Player.belongsToMany(Team, {
+        as: 'Teams',
+        through: PlayerTeam,
+        foreignKey: 'player_id',
+        otherKey: 'team_id'
+    });
+    Player.hasMany(BoxScore, { as: 'BoxScores', foreignKey: 'player_id' });
+    Player.hasMany(CompetitionMVP, { as: 'CompetitionMVPs', foreignKey: 'player_id' });
+    Player.hasMany(VPER, { as: 'VPERs', foreignKey: 'player_id' });
+    Player.hasMany(PlayerTeam, { as: 'PlayerTeams', foreignKey: 'player_id' });
+    Player.hasOne(PerformanceStats, { as: 'PerformanceStat', foreignKey: 'player_id' });
+    Player.hasMany(PlayerImprovementLog, { as: 'ImprovementLogs', foreignKey: 'player_id' });
+    PlayerImprovementLog.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
+    PlayerImprovementLog.belongsTo(Match, { as: 'match', foreignKey: 'match_id' });
+    Match.hasMany(PlayerImprovementLog, { as: 'ImprovementLogs', foreignKey: 'match_id' });
+    Player.hasOne(BoxScoreTotals, { as: 'BoxScoreTotals', foreignKey: 'player_id' });
+    PlayerTeam.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
+    PlayerTeam.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
+    Rally.belongsTo(MatchSet, { as: 'matchSet', foreignKey: 'match_set_id' });
+    Rally.belongsTo(Team, { as: 'ServingTeam', foreignKey: 'serving_team' });
+    PromotionMatch.belongsTo(Iteration, { as: 'iterationData', foreignKey: 'iteration' });
+    PromotionMatch.belongsTo(Match, { as: 'Match', foreignKey: 'match_id' });
+    PromotionMatch.belongsTo(Competition, { as: 'upperCompetition', foreignKey: 'upper_competition' });
+    PromotionMatch.belongsTo(Competition, { as: 'lowerCompetition', foreignKey: 'lower_competition' });
+    RegionQualifier.belongsTo(Iteration, { as: 'Iteration', foreignKey: 'iteration' });
+    RegionQualifier.belongsTo(Country, { as: 'countryRegion', foreignKey: 'region_code', targetKey: 'region_code' });
+    RegionQualifier.belongsTo(Competition, { as: 'competition', foreignKey: 'competition_id' });
+    Competition.hasOne(RegionQualifier, { as: 'RegionQualifier', foreignKey: 'competition_id' });
+    VPER.belongsTo(Player, { as: 'Player', foreignKey: 'player_id' });
+    VPER.belongsTo(Match, { as: 'Match', foreignKey: 'match_id' });
+    Team.hasOne(Coach, { as: 'Coach', foreignKey: 'team_id' });
+    Coach.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
+    Team.hasOne(Tactics, { as: 'tactics', foreignKey: 'team_id' });
+    Team.belongsTo(Country, { as: 'country', foreignKey: 'country_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(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' });
+    Team.hasMany(CompetitionStandings, { as: 'CompetitionStandings', foreignKey: 'team_id' });
+    Team.hasOne(UserTeam, { as: 'UserTeam', foreignKey: 'team_id' });
+    Team.hasOne(TeamReplacement, { as: 'TeamReplacement', foreignKey: 'team_id' });
+    TeamReplacement.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
+    TeamReplacement.belongsTo(Team, { as: 'replacedByTeam', foreignKey: 'replaced_by' });
+    Player.hasOne(UserPlayerProgress, { as: 'UserPlayerProgress', foreignKey: 'player_id' });
+    UserPlayerProgress.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
+    return {
+        AuthIdentity,
+        AuthSession,
+        AuthUser,
+        Competition,
+        CompetitionChampion,
+        CompetitionMatch,
+        CompetitionMVP,
+        CompetitionStandings,
+        CompetitionStandingsMatch,
+        CompetitionTeams,
+        Country,
+        Division,
+        Iteration,
+        League,
+        DivisionSeason,
+        Match,
+        MatchRating,
+        MatchResult,
+        MatchSet,
+        BoxScore,
+        BoxScoreTotals,
+        PerformanceStats,
+        Player,
+        PlayerTeam,
+        PlayerImprovementLog,
+        PromotionMatch,
+        RegionQualifier,
+        Rally,
+        Team,
+        TeamReplacement,
+        Tactics,
+        UserTeam,
+        UserCurrency,
+        UserPlayerProgress,
+        GachaPity,
+        GachaPullHistory,
+        UserPullGrant,
+        Wishlist,
+        UserSettings,
+        Notification,
+        Coach,
+        CurrencyTransaction,
+        VPER
+    };
+}

package/dist/cjs/src/data/models/auth-identity.d.ts

@@ -0,0 +1,35 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import { AuthUserId, AuthUserModel } from '.';
+export interface AuthIdentityAttributes {
+    identity_id: string;
+    user_id: string;
+    provider: AuthProvider;
+    provider_user_id: string;
+    email?: string | null;
+    password_hash?: string | null;
+    last_used_at?: Date | null;
+    created_at?: Date;
+    updated_at?: Date;
+}
+export type AuthIdentityPk = 'identity_id';
+export type AuthIdentityId = AuthIdentityModel[AuthIdentityPk];
+export type AuthProvider = 'EMAIL' | 'GOOGLE' | 'FACEBOOK' | 'APPLE';
+export type AuthIdentityOptionalAttributes = 'email' | 'password_hash' | 'last_used_at' | 'created_at' | 'updated_at';
+export type AuthIdentityCreationAttributes = Optional<AuthIdentityAttributes, AuthIdentityOptionalAttributes>;
+export declare class AuthIdentityModel extends Model<AuthIdentityAttributes, AuthIdentityCreationAttributes> implements AuthIdentityAttributes {
+    identity_id: string;
+    user_id: string;
+    provider: AuthProvider;
+    provider_user_id: string;
+    email?: string | null;
+    password_hash?: string | null;
+    last_used_at?: Date | null;
+    created_at?: Date;
+    updated_at?: Date;
+    user: AuthUserModel;
+    getUser: Sequelize.BelongsToGetAssociationMixin<AuthUserModel>;
+    setUser: Sequelize.BelongsToSetAssociationMixin<AuthUserModel, AuthUserId>;
+    createUser: Sequelize.BelongsToCreateAssociationMixin<AuthUserModel>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof AuthIdentityModel;
+}