volleyballsimtypes 0.0.358 → 0.0.359

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

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

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

@@ -1,22 +0,0 @@
-"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 +0,0 @@
-import type { Sequelize } from 'sequelize';
-export declare function initModels(sequelize: Sequelize): any;

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

@@ -1,265 +0,0 @@
-"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

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

@@ -1,75 +0,0 @@
-"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

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

@@ -1,74 +0,0 @@
-"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

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

@@ -1,74 +0,0 @@
-"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;