volleyballsimtypes 0.0.359 → 0.0.360

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,265 @@
+"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;
+}

package/dist/cjs/src/data/models/auth-identity.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthIdentityModel = void 0;
+const sequelize_1 = require("sequelize");
+class AuthIdentityModel extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return AuthIdentityModel.init({
+            identity_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true
+            },
+            user_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'AuthUser',
+                    key: 'user_id'
+                }
+            },
+            provider: {
+                type: sequelize_1.DataTypes.ENUM('EMAIL', 'GOOGLE', 'FACEBOOK', 'APPLE'),
+                allowNull: false
+            },
+            provider_user_id: {
+                type: sequelize_1.DataTypes.STRING,
+                allowNull: false
+            },
+            email: {
+                type: sequelize_1.DataTypes.STRING,
+                allowNull: true
+            },
+            password_hash: {
+                type: sequelize_1.DataTypes.STRING,
+                allowNull: true
+            },
+            last_used_at: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: true
+            },
+            created_at: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: sequelize_1.DataTypes.NOW
+            },
+            updated_at: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: sequelize_1.DataTypes.NOW
+            }
+        }, {
+            sequelize,
+            tableName: 'AuthIdentity',
+            schema: 'public',
+            timestamps: false,
+            indexes: [
+                {
+                    name: 'AuthIdentity_pk',
+                    unique: true,
+                    fields: [{ name: 'identity_id' }]
+                },
+                {
+                    name: 'AuthIdentity_provider_uid_uq',
+                    unique: true,
+                    fields: [{ name: 'provider' }, { name: 'provider_user_id' }]
+                },
+                {
+                    name: 'AuthIdentity_user_id_idx',
+                    fields: [{ name: 'user_id' }]
+                }
+            ]
+        });
+    }
+}
+exports.AuthIdentityModel = AuthIdentityModel;

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

@@ -0,0 +1,34 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import { AuthUserId, AuthUserModel } from '.';
+export interface AuthSessionAttributes {
+    session_id: string;
+    user_id: string;
+    refresh_token_hash: string;
+    expires_at: Date;
+    revoked_at?: Date | null;
+    ip_address?: string | null;
+    user_agent?: string | null;
+    created_at?: Date;
+    updated_at?: Date;
+}
+export type AuthSessionPk = 'session_id';
+export type AuthSessionId = AuthSessionModel[AuthSessionPk];
+export type AuthSessionOptionalAttributes = 'revoked_at' | 'ip_address' | 'user_agent' | 'created_at' | 'updated_at';
+export type AuthSessionCreationAttributes = Optional<AuthSessionAttributes, AuthSessionOptionalAttributes>;
+export declare class AuthSessionModel extends Model<AuthSessionAttributes, AuthSessionCreationAttributes> implements AuthSessionAttributes {
+    session_id: string;
+    user_id: string;
+    refresh_token_hash: string;
+    expires_at: Date;
+    revoked_at?: Date | null;
+    ip_address?: string | null;
+    user_agent?: string | 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 AuthSessionModel;
+}

package/dist/cjs/src/data/models/auth-session.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthSessionModel = void 0;
+const sequelize_1 = require("sequelize");
+class AuthSessionModel extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return AuthSessionModel.init({
+            session_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true
+            },
+            user_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'AuthUser',
+                    key: 'user_id'
+                }
+            },
+            refresh_token_hash: {
+                type: sequelize_1.DataTypes.STRING,
+                allowNull: false
+            },
+            expires_at: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false
+            },
+            revoked_at: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: true
+            },
+            ip_address: {
+                type: sequelize_1.DataTypes.STRING,
+                allowNull: true
+            },
+            user_agent: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: true
+            },
+            created_at: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: sequelize_1.DataTypes.NOW
+            },
+            updated_at: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: sequelize_1.DataTypes.NOW
+            }
+        }, {
+            sequelize,
+            tableName: 'AuthSession',
+            schema: 'public',
+            timestamps: false,
+            indexes: [
+                {
+                    name: 'AuthSession_pk',
+                    unique: true,
+                    fields: [{ name: 'session_id' }]
+                },
+                {
+                    name: 'AuthSession_user_id_idx',
+                    fields: [{ name: 'user_id' }]
+                },
+                {
+                    name: 'AuthSession_expires_at_idx',
+                    fields: [{ name: 'expires_at' }]
+                }
+            ]
+        });
+    }
+}
+exports.AuthSessionModel = AuthSessionModel;

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

@@ -0,0 +1,56 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import { AuthIdentityId, AuthIdentityModel, AuthSessionId, AuthSessionModel } from '.';
+export interface AuthUserAttributes {
+    user_id: string;
+    email: string;
+    role: AuthUserRole;
+    display_name?: string | null;
+    avatar_url?: string | null;
+    status: AuthUserStatus;
+    email_verified_at?: Date | null;
+    last_login_at?: Date | null;
+    created_at?: Date;
+    updated_at?: Date;
+}
+export type AuthUserPk = 'user_id';
+export type AuthUserId = AuthUserModel[AuthUserPk];
+export type AuthUserRole = 'ADMIN' | 'PLAYER';
+export type AuthUserStatus = 'ACTIVE' | 'DISABLED' | 'PENDING';
+export type AuthUserOptionalAttributes = 'role' | 'display_name' | 'avatar_url' | 'status' | 'email_verified_at' | 'last_login_at' | 'created_at' | 'updated_at';
+export type AuthUserCreationAttributes = Optional<AuthUserAttributes, AuthUserOptionalAttributes>;
+export declare class AuthUserModel extends Model<AuthUserAttributes, AuthUserCreationAttributes> implements AuthUserAttributes {
+    user_id: string;
+    email: string;
+    role: AuthUserRole;
+    display_name?: string | null;
+    avatar_url?: string | null;
+    status: AuthUserStatus;
+    email_verified_at?: Date | null;
+    last_login_at?: Date | null;
+    created_at?: Date;
+    updated_at?: Date;
+    AuthIdentities: AuthIdentityModel[];
+    getAuthIdentities: Sequelize.HasManyGetAssociationsMixin<AuthIdentityModel>;
+    setAuthIdentities: Sequelize.HasManySetAssociationsMixin<AuthIdentityModel, AuthIdentityId>;
+    addAuthIdentity: Sequelize.HasManyAddAssociationMixin<AuthIdentityModel, AuthIdentityId>;
+    addAuthIdentities: Sequelize.HasManyAddAssociationsMixin<AuthIdentityModel, AuthIdentityId>;
+    createAuthIdentity: Sequelize.HasManyCreateAssociationMixin<AuthIdentityModel>;
+    removeAuthIdentity: Sequelize.HasManyRemoveAssociationMixin<AuthIdentityModel, AuthIdentityId>;
+    removeAuthIdentities: Sequelize.HasManyRemoveAssociationsMixin<AuthIdentityModel, AuthIdentityId>;
+    hasAuthIdentity: Sequelize.HasManyHasAssociationMixin<AuthIdentityModel, AuthIdentityId>;
+    hasAuthIdentities: Sequelize.HasManyHasAssociationsMixin<AuthIdentityModel, AuthIdentityId>;
+    countAuthIdentities: Sequelize.HasManyCountAssociationsMixin;
+    AuthSessions: AuthSessionModel[];
+    getAuthSessions: Sequelize.HasManyGetAssociationsMixin<AuthSessionModel>;
+    setAuthSessions: Sequelize.HasManySetAssociationsMixin<AuthSessionModel, AuthSessionId>;
+    addAuthSession: Sequelize.HasManyAddAssociationMixin<AuthSessionModel, AuthSessionId>;
+    addAuthSessions: Sequelize.HasManyAddAssociationsMixin<AuthSessionModel, AuthSessionId>;
+    createAuthSession: Sequelize.HasManyCreateAssociationMixin<AuthSessionModel>;
+    removeAuthSession: Sequelize.HasManyRemoveAssociationMixin<AuthSessionModel, AuthSessionId>;
+    removeAuthSessions: Sequelize.HasManyRemoveAssociationsMixin<AuthSessionModel, AuthSessionId>;
+    hasAuthSession: Sequelize.HasManyHasAssociationMixin<AuthSessionModel, AuthSessionId>;
+    hasAuthSessions: Sequelize.HasManyHasAssociationsMixin<AuthSessionModel, AuthSessionId>;
+    countAuthSessions: Sequelize.HasManyCountAssociationsMixin;
+    static initModel(sequelize: Sequelize.Sequelize): typeof AuthUserModel;
+}

package/dist/cjs/src/data/models/auth-user.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthUserModel = void 0;
+const sequelize_1 = require("sequelize");
+class AuthUserModel extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return AuthUserModel.init({
+            user_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true
+            },
+            email: {
+                type: sequelize_1.DataTypes.STRING,
+                allowNull: false,
+                unique: 'AuthUser_email_uq'
+            },
+            role: {
+                type: sequelize_1.DataTypes.ENUM('ADMIN', 'PLAYER'),
+                allowNull: false,
+                defaultValue: 'PLAYER'
+            },
+            display_name: {
+                type: sequelize_1.DataTypes.STRING,
+                allowNull: true
+            },
+            avatar_url: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: true
+            },
+            status: {
+                type: sequelize_1.DataTypes.ENUM('ACTIVE', 'DISABLED', 'PENDING'),
+                allowNull: false,
+                defaultValue: 'PENDING'
+            },
+            email_verified_at: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: true
+            },
+            last_login_at: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: true
+            },
+            created_at: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: sequelize_1.DataTypes.NOW
+            },
+            updated_at: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: sequelize_1.DataTypes.NOW
+            }
+        }, {
+            sequelize,
+            tableName: 'AuthUser',
+            schema: 'public',
+            timestamps: false,
+            indexes: [
+                {
+                    name: 'AuthUser_pk',
+                    unique: true,
+                    fields: [{ name: 'user_id' }]
+                },
+                {
+                    name: 'AuthUser_email_uq',
+                    unique: true,
+                    fields: [{ name: 'email' }]
+                }
+            ]
+        });
+    }
+}
+exports.AuthUserModel = AuthUserModel;