volleyballsimtypes 0.0.491 → 0.0.493

package/dist/cjs/src/service/notification/notification-type.d.ts

@@ -1,4 +1,4 @@
-export declare const NOTIFICATION_TYPES: readonly ["MATCH_RESULT", "INJURY", "INJURY_RECOVERED", "SEASON_END", "GRANT_RECEIVED", "PROMOTION", "DAILY_LOGIN", "WELCOME", "COMPENSATION"];
+export declare const NOTIFICATION_TYPES: readonly ["MATCH_RESULT", "INJURY", "INJURY_RECOVERED", "SEASON_END", "GRANT_RECEIVED", "PROMOTION", "DAILY_LOGIN", "WELCOME", "COMPENSATION", "EVENT_REGISTRATION_OPEN", "EVENT_REGISTRATION_CLOSING", "EVENT_STARTED", "EVENT_FINAL_ROUND", "EVENT_FINISHED"];
 export type NotificationType = typeof NOTIFICATION_TYPES[number];
 export declare const NOTIFICATION_LOCALES: readonly ["en", "es", "fr", "it", "pl", "pt-BR", "tr"];
 export type NotificationLocale = typeof NOTIFICATION_LOCALES[number];

package/dist/cjs/src/service/notification/notification-type.js

@@ -16,7 +16,12 @@ exports.NOTIFICATION_TYPES = [
     'PROMOTION',
     'DAILY_LOGIN',
     'WELCOME',
-    'COMPENSATION'
+    'COMPENSATION',
+    'EVENT_REGISTRATION_OPEN',
+    'EVENT_REGISTRATION_CLOSING',
+    'EVENT_STARTED',
+    'EVENT_FINAL_ROUND',
+    'EVENT_FINISHED'
 ];
 // The 7 supported locales. Must stay in sync with the API VALID_LOCALES set and the UI src/locales/*.json.
 exports.NOTIFICATION_LOCALES = ['en', 'es', 'fr', 'it', 'pl', 'pt-BR', 'tr'];

package/dist/cjs/src/service/notification/notification.test.js

@@ -132,7 +132,9 @@ function flattenStrings(node, prefix = '') {
             .toEqual(notification_type_1.NOTIFICATION_TYPES.filter((t) => registry_1.NOTIFICATION_REGISTRY[t].emitsPush).sort((a, b) => a.localeCompare(b)));
         (0, globals_1.expect)(registry_1.PUSH_NOTIFICATION_TYPES).not.toContain('COMPENSATION');
         (0, globals_1.expect)(registry_1.PUSH_NOTIFICATION_TYPES).toContain('MATCH_RESULT');
-        (0, globals_1.expect)(registry_1.PUSH_NOTIFICATION_TYPES).toHaveLength(8);
+        // COMPENSATION is the ONLY in-app-only type, so every other type pushes. Expressed as a relationship
+        // rather than a count, so adding a type does not need this number edited.
+        (0, globals_1.expect)(registry_1.PUSH_NOTIFICATION_TYPES).toHaveLength(notification_type_1.NOTIFICATION_TYPES.length - 1);
     });
     (0, globals_1.it)('is opt-out: absent / null / empty / true all enable, only explicit false suppresses', () => {
         (0, globals_1.expect)((0, notification_type_1.pushEnabledFor)(undefined, 'MATCH_RESULT')).toBe(true);

package/dist/cjs/src/service/notification/registry.js

@@ -88,6 +88,58 @@ exports.NOTIFICATION_REGISTRY = {
         inAppMessageKey: 'promotion.body',
         catalogKeys: ['promotion.title', 'promotion.body']
     },
+    // In-game events. All five deep-link to the Events section, which is where every phase of an event lives.
+    // eventName is the event's key; the UI resolves it to the translated name, so the catalog copy interpolates
+    // a key rather than a localised string the sender would have to translate.
+    EVENT_REGISTRATION_OPEN: {
+        emitsPush: true,
+        deepLink: () => '/events',
+        pushTitleKey: 'eventRegistrationOpen.title',
+        pushBodyKey: 'eventRegistrationOpen.body',
+        inAppMessageKey: 'eventRegistrationOpen.body',
+        catalogKeys: ['eventRegistrationOpen.title', 'eventRegistrationOpen.body']
+    },
+    EVENT_REGISTRATION_CLOSING: {
+        emitsPush: true,
+        deepLink: () => '/events',
+        pushTitleKey: 'eventRegistrationClosing.title',
+        pushBodyKey: 'eventRegistrationClosing.body',
+        inAppMessageKey: 'eventRegistrationClosing.body',
+        catalogKeys: ['eventRegistrationClosing.title', 'eventRegistrationClosing.body']
+    },
+    EVENT_STARTED: {
+        emitsPush: true,
+        deepLink: () => '/events',
+        pushTitleKey: 'eventStarted.title',
+        pushBodyKey: 'eventStarted.body',
+        inAppMessageKey: 'eventStarted.body',
+        catalogKeys: ['eventStarted.title', 'eventStarted.body']
+    },
+    EVENT_FINAL_ROUND: {
+        emitsPush: true,
+        deepLink: () => '/events',
+        pushTitleKey: 'eventFinalRound.title',
+        pushBodyKey: 'eventFinalRound.body',
+        inAppMessageKey: 'eventFinalRound.body',
+        catalogKeys: ['eventFinalRound.title', 'eventFinalRound.body']
+    },
+    EVENT_FINISHED: {
+        emitsPush: true,
+        deepLink: () => '/events',
+        pushTitleKey: 'eventFinished.title',
+        // Copy depends on whether we know where they finished; a missing position never renders "You finished th".
+        pushBodyKey: (p) => readString(p.position) != null || typeof p.position === 'number'
+            ? 'eventFinished.placed'
+            : 'eventFinished.body',
+        inAppMessageKey: (p) => readString(p.position) != null || typeof p.position === 'number'
+            ? 'eventFinished.placed'
+            : 'eventFinished.body',
+        params: (p) => ({
+            position: typeof p.position === 'number' ? String(p.position) : (readString(p.position) ?? ''),
+            entrants: typeof p.entrants === 'number' ? String(p.entrants) : (readString(p.entrants) ?? '')
+        }),
+        catalogKeys: ['eventFinished.title', 'eventFinished.body', 'eventFinished.placed']
+    },
     DAILY_LOGIN: {
         emitsPush: true,
         // Fires when the reward becomes claimable (00:00 UTC), so it opens the daily-login claim view.

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

@@ -35,13 +35,14 @@ export interface GachaPullConfig {
 }
 export declare const NORMAL_PULL_CONFIG: GachaPullConfig;
 export declare const QUALIFIER_PULL_CONFIG: GachaPullConfig;
+export declare const EVENT_PULL_CONFIG: GachaPullConfig;
 export declare const TOURNAMENT_PULL_CONFIG: GachaPullConfig;
 export declare function scoutPullConfig(level: string): GachaPullConfig;
 export declare function rollRarity(pity: PityState, config?: GachaPullConfig): RollResult;
 export declare class PlayerGenerator {
     private constructor();
     private static generatePerformance;
-    static generatePlayer(country: Country, _rarity?: Rarity, role?: Role, maxTraits?: boolean, birthIteration?: number): Player;
+    static generatePlayer(country: Country, _rarity?: Rarity, role?: Role, maxTraits?: boolean, birthIteration?: number, topSkew?: number): Player;
     static generatePlayers(count: number, countries: Country[]): Player[];
 }
 export declare function pickPlayerCountry(teamCountry: Country, allCountries: Country[]): Country;

package/dist/cjs/src/service/player/player-generator.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PlayerGenerator = exports.TOURNAMENT_PULL_CONFIG = exports.QUALIFIER_PULL_CONFIG = exports.NORMAL_PULL_CONFIG = exports.PITY_STEP = exports.PITY_THRESHOLDS = void 0;
+exports.PlayerGenerator = exports.TOURNAMENT_PULL_CONFIG = exports.EVENT_PULL_CONFIG = exports.QUALIFIER_PULL_CONFIG = exports.NORMAL_PULL_CONFIG = exports.PITY_STEP = exports.PITY_THRESHOLDS = void 0;
 exports.scoutPullConfig = scoutPullConfig;
 exports.rollRarity = rollRarity;
 exports.pickPlayerCountry = pickPlayerCountry;
@@ -69,6 +69,21 @@ exports.QUALIFIER_PULL_CONFIG = {
     accumulateMythicPity: true,
     accumulateSpecialPity: true
 };
+// Event Pack (x5): the NATIONAL pool and structure, with TRIPLE the legendary and mythic chance. Special is
+// untouched and rare absorbs the difference, so it still sums to 1. Builds all three pities, like NATIONAL.
+// Owner-defined 2026-07-23.
+exports.EVENT_PULL_CONFIG = {
+    special: 0.003,
+    mythic: 0.03,
+    legendary: 0.30,
+    rare: 0.667,
+    applyLegendaryPity: true,
+    applyMythicPity: true,
+    applySpecialPity: true,
+    accumulateLegendaryPity: true,
+    accumulateMythicPity: true,
+    accumulateSpecialPity: true
+};
 // Tournament gacha (x5 per match): LEGENDARY–SPECIAL, no legendary pity (floor is legendary)
 exports.TOURNAMENT_PULL_CONFIG = {
     special: 0.01,
@@ -194,7 +209,7 @@ function rollRarity(pity, config = WORLD_PULL_CONFIG) {
 /* eslint-disable @typescript-eslint/no-extraneous-class */
 class PlayerGenerator {
     constructor() { }
-    static generatePerformance(rarity, role) {
+    static generatePerformance(rarity, role, topSkew = 0) {
         const ATTACK = (0, stats_1.getMultipliers)(stats_1.StatsEnum.ATTACK);
         const SET = (0, stats_1.getMultipliers)(stats_1.StatsEnum.SET);
         const RECEIVE = (0, stats_1.getMultipliers)(stats_1.StatsEnum.RECEIVE);
@@ -205,8 +220,10 @@ class PlayerGenerator {
                 // Stamina always uses its own per-rarity range (guaranteed floor), regardless of role weight.
                 if (key === 'stamina')
                     return [key, rollStamina(rarity)];
+                // On-role stats drive the role score, so a positive topSkew bends only these toward the top of the
+                // range; off-role stats stay uniform. topSkew defaults to 0 (the historic uniform draw).
                 if (weights[key] > 0)
-                    return [key, (0, node_crypto_1.randomInt)(minValue, maxValue + 1)];
+                    return [key, randomIntSkewed(minValue, maxValue, topSkew)];
                 else
                     return [key, (0, node_crypto_1.randomInt)(rarity_1.RarityRanges.COMMON[0], Math.max(minValue - 1, rarity_1.RarityRanges.COMMON[0] + 1))];
             })));
@@ -300,10 +317,10 @@ class PlayerGenerator {
             }
         }
     }
-    static generatePlayer(country, _rarity, role, maxTraits, birthIteration = 1) {
+    static generatePlayer(country, _rarity, role, maxTraits, birthIteration = 1, topSkew = 0) {
         const rarity = _rarity ?? rollRarity({ legendaryPity: 0, mythicPity: 0, specialPity: 0 }).rarity;
         const name = (0, utils_1.generatePlayerName)(country.locales, 1)[0];
-        const stats = PlayerGenerator.generatePerformance(rarity, role);
+        const stats = PlayerGenerator.generatePerformance(rarity, role, topSkew);
         const roles = (0, role_1.assignRoles)(stats, rarity, role);
         const traits = (0, trait_1.assignTraits)(roles, rarity, maxTraits);
         const birthAge = (0, node_crypto_1.randomInt)(15, 21);
@@ -345,6 +362,21 @@ function rollStamina(rarity) {
     const [low, high] = rarity_1.StaminaRanges[rarity];
     return (0, node_crypto_1.randomInt)(low, high + 1);
 }
+/**
+ * A crypto.randomInt draw over [min, max] inclusive, optionally skewed toward the top.
+ *
+ * skew = 0 is the plain uniform draw the generator has always used. A positive skew bends a uniform fraction
+ * upward with u^(1/(1+skew)), so higher values become progressively likelier while the maximum is never forced,
+ * which keeps the result random rather than a maxed stat. Event drafts use this to make the lower rarities'
+ * recruits cluster near the top of their range (see EVENT_DRAFT_TOP_SKEW).
+ */
+function randomIntSkewed(min, max, skew) {
+    if (skew <= 0 || max <= min)
+        return (0, node_crypto_1.randomInt)(min, max + 1);
+    const u = (0, node_crypto_1.randomInt)(0, 1000001) / 1000000;
+    const frac = Math.pow(u, 1 / (1 + skew));
+    return min + Math.round(frac * (max - min));
+}
 function assignValues(stat, low, high, performance) {
     performance_stats_1.performanceStatKeys.filter((key) => stat[key] != null && stat[key] > 0)
         .forEach((key) => {

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

@@ -1,4 +1,5 @@
 import { BoxScore, DataProps, DeclineStatus, Division as _Division, League as _League, Match as _Match, MatchSet as _MatchSet, Player as _Player, PlayerPosition, Qualifier as _Qualifier, QualifierMatch as _QualifierMatch, Rally as _Rally, RallyEvent as _RallyEvent, PointBreakdown, RallyMetrics, Season as _Season, Standing as _Standing, Team as _Team, Tournament as _Tournament, TournamentMatch as _TournamentMatch, National as _National, NationalMatch as _NationalMatch, Country as _Country, BlockingAssignment, CourtPosition, ConditionLogic, EnergyBand, MatchForfeitType, PerformanceStats, PinchCondition, RotationSystemEnum, SubBackMode, SubBand } from '../service';
+export * from './tactics-player-refs';
 export type Rally = DataProps<_Rally> & {
     homePlayerPosition: PlayerPosition[];
     awayPlayerPosition: PlayerPosition[];
@@ -16,7 +17,7 @@ export interface Results {
     away: number[];
 }
 export interface MatchCompetition {
-    type: 'LEAGUE' | 'NATIONAL' | 'QUALIFIER' | 'TOURNAMENT';
+    type: 'LEAGUE' | 'NATIONAL' | 'QUALIFIER' | 'TOURNAMENT' | 'EVENT';
     countryName?: string;
     countryAlpha2?: string;
     countryAlpha3?: string;

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

@@ -1 +1,2 @@
 import { CourtPosition } from '../service';
+export * from './tactics-player-refs';

package/dist/esm/src/api/tactics-player-refs.d.ts

@@ -0,0 +1,13 @@
+import type { Tactics } from '.';
+/**
+ * Every player id a tactics config references, anywhere: the six court slots and the libero, the bench, libero
+ * replacements (flat and per-set), the second libero, designated subs and their per-set overrides, designated
+ * setters (flat and per-set), the keys of the offensive-weight and blocking-target maps, injury replacements
+ * and the libero-injury reserves.
+ *
+ * There is exactly ONE implementation of this on purpose. It backs three rules that must agree or a player
+ * slips through: the dismiss/retire guard (a referenced player cannot be removed), the event rarity check
+ * (every referenced player must match the event's rarity), and the simulator's re-validation of an event entry
+ * at the registration deadline. A field missed here silently unlocks a player in all three.
+ */
+export declare function collectTacticsPlayerIds(config: Tactics): string[];

package/dist/esm/src/api/tactics-player-refs.js

@@ -0,0 +1,40 @@
+/**
+ * Every player id a tactics config references, anywhere: the six court slots and the libero, the bench, libero
+ * replacements (flat and per-set), the second libero, designated subs and their per-set overrides, designated
+ * setters (flat and per-set), the keys of the offensive-weight and blocking-target maps, injury replacements
+ * and the libero-injury reserves.
+ *
+ * There is exactly ONE implementation of this on purpose. It backs three rules that must agree or a player
+ * slips through: the dismiss/retire guard (a referenced player cannot be removed), the event rarity check
+ * (every referenced player must match the event's rarity), and the simulator's re-validation of an event entry
+ * at the registration deadline. A field missed here silently unlocks a player in all three.
+ */
+export function collectTacticsPlayerIds(config) {
+    const lineup = config.lineup;
+    const referenced = [
+        lineup[0], lineup[1], lineup[2], lineup[3], lineup[4], lineup[5], lineup[6],
+        ...(Array.isArray(lineup.bench) ? lineup.bench : []),
+        ...(config.liberoReplacements ?? []),
+        ...((config.designatedSubs ?? []).flatMap(ds => [
+            ds.starterId,
+            ds.benchId,
+            ...((ds.sets ?? []).map(s => s.benchId))
+        ])),
+        config.secondLibero,
+        ...((config.liberoReplacementSets ?? []).flat()),
+        ...(config.designatedSetters ?? []),
+        ...((config.offensivePreferences ?? []).flatMap(p => Object.keys(p.weights))),
+        ...((config.systemSets ?? []).flatMap(s => s.designatedSetters)),
+        ...((config.offensivePreferenceSets ?? []).flat().flatMap(p => Object.keys(p.weights))),
+        ...((config.blockingPreferences ?? []).flatMap(p => Object.keys(p.targets))),
+        ...((config.blockingPreferenceSets ?? []).flat().flatMap(p => Object.keys(p.targets))),
+        // Injury replacements reference reserves (roster players outside the lineup); roster membership is the only
+        // player check possible here (the schema enforces the bench/reserve role rules).
+        ...((config.injuryReplacements ?? []).flatMap(ir => [ir.starterId, ir.replacementId, ir.benchBackfillId])),
+        // Libero-injury ids reference reserves/bench players; roster membership is the only check possible here.
+        ...(config.liberoInjury != null
+            ? [config.liberoInjury.preMatchReplacementId, config.liberoInjury.secondLiberoBackfillId, config.liberoInjury.inMatchDesignateId]
+            : [])
+    ];
+    return [...new Set(referenced.filter((id) => typeof id === 'string' && id.length > 0))];
+}

package/dist/esm/src/data/event-purge.d.ts

@@ -0,0 +1,14 @@
+import { Sequelize } from 'sequelize';
+/**
+ * Delete everything an event produced, keeping only the Event row itself (with purged_at stamped) so the game
+ * retains a record that it ran. Pass `removeEvent` to drop that row too, which is what an admin delete does.
+ *
+ * Order matters: MatchResult has no FK to Match and must go explicitly (same as the weekly friendly purge);
+ * deleting the Match then cascades MatchSet -> Rally/BoxScore, VPER, MatchRating, PlayerImprovementLog and
+ * MatchPreset. The drafted squads go the same way as the bots: their throwaway teams and every player in them
+ * are deleted, along with any packs whose choices were never picked.
+ *
+ * EventResult is deliberately NOT touched. It is the permanent record of where each entrant finished and the
+ * only event row besides Event itself that outlives this.
+ */
+export declare function purgeEvent(sequelize: Sequelize, eventId: string, removeEvent?: boolean): Promise<void>;

package/dist/esm/src/data/event-purge.js

@@ -0,0 +1,110 @@
+import { QueryTypes } from 'sequelize';
+import { CompetitionMatchModel, CompetitionModel, CompetitionStandingsModel, CompetitionTeamsModel, EventBotTeamModel, EventCompetitionModel, EventPackModel, EventPackPlayerModel, EventSquadModel, EventModel, LineupPresetModel, MatchModel, MatchResultModel, PlayerModel, PlayerTeamModel, TeamModel } from './models';
+import logger from '../logger';
+// Tearing an event down. This lives in Types rather than in either service because BOTH perform it and they
+// must agree exactly: the simulator purges an event on its scheduled date, and the admin API purges one that
+// is being deleted outright. A second implementation of a destructive delete is how orphans get left behind.
+/**
+ * Delete everything an event produced, keeping only the Event row itself (with purged_at stamped) so the game
+ * retains a record that it ran. Pass `removeEvent` to drop that row too, which is what an admin delete does.
+ *
+ * Order matters: MatchResult has no FK to Match and must go explicitly (same as the weekly friendly purge);
+ * deleting the Match then cascades MatchSet -> Rally/BoxScore, VPER, MatchRating, PlayerImprovementLog and
+ * MatchPreset. The drafted squads go the same way as the bots: their throwaway teams and every player in them
+ * are deleted, along with any packs whose choices were never picked.
+ *
+ * EventResult is deliberately NOT touched. It is the permanent record of where each entrant finished and the
+ * only event row besides Event itself that outlives this.
+ */
+export async function purgeEvent(sequelize, eventId, removeEvent = false) {
+    await sequelize.transaction(async (transaction) => {
+        const competitions = await EventCompetitionModel.findAll({
+            where: { event_id: eventId },
+            attributes: ['competition_id'],
+            transaction
+        });
+        const competitionIds = competitions.map(c => c.competition_id);
+        const botTeams = await EventBotTeamModel.findAll({
+            where: { event_id: eventId },
+            attributes: ['team_id'],
+            transaction
+        });
+        const squads = await EventSquadModel.findAll({
+            where: { event_id: eventId },
+            attributes: ['team_id'],
+            transaction
+        });
+        // Bots and drafted squads are the same thing here: throwaway teams full of generated players.
+        const botTeamIds = [...botTeams.map(b => b.team_id), ...squads.map(s => s.team_id)];
+        if (competitionIds.length > 0) {
+            const matchRows = await CompetitionMatchModel.findAll({
+                where: { competition_id: competitionIds },
+                attributes: ['match_id'],
+                transaction
+            });
+            const matchIds = matchRows.map(m => m.match_id);
+            if (matchIds.length > 0) {
+                await MatchResultModel.destroy({ where: { match_id: matchIds }, transaction });
+                await CompetitionMatchModel.destroy({ where: { competition_id: competitionIds }, transaction });
+                await MatchModel.destroy({ where: { match_id: matchIds }, transaction });
+            }
+            await CompetitionStandingsModel.destroy({ where: { competition_id: competitionIds }, transaction });
+            await sequelize.query('DELETE FROM "CompetitionStandingsMatch" WHERE competition_id IN (:ids)', {
+                replacements: { ids: competitionIds }, type: QueryTypes.DELETE, transaction
+            });
+            await CompetitionTeamsModel.destroy({ where: { competition_id: competitionIds }, transaction });
+            await EventCompetitionModel.destroy({ where: { event_id: eventId }, transaction });
+            await CompetitionModel.destroy({ where: { competition_id: competitionIds }, transaction });
+        }
+        // Packs first: an unpicked choice still points at a Player row, and the pack points at the picked one, so
+        // both references have to go before the players themselves.
+        const packs = await EventPackModel.findAll({
+            where: { event_id: eventId },
+            attributes: ['pack_id'],
+            transaction
+        });
+        if (packs.length > 0) {
+            const packIds = packs.map(p => p.pack_id);
+            const choices = await EventPackPlayerModel.findAll({
+                where: { pack_id: packIds },
+                attributes: ['player_id'],
+                transaction
+            });
+            await EventPackPlayerModel.destroy({ where: { pack_id: packIds }, transaction });
+            await EventPackModel.destroy({ where: { event_id: eventId }, transaction });
+            // Choices that were never picked belong to no team, so nothing below would reach them.
+            const looseIds = choices.map(c => c.player_id);
+            if (looseIds.length > 0) {
+                await PlayerTeamModel.destroy({ where: { player_id: looseIds }, transaction });
+                await PlayerModel.destroy({ where: { player_id: looseIds }, transaction });
+            }
+        }
+        // Squads and event lineups go before the teams so no FK from a preset can block the team delete.
+        await EventSquadModel.destroy({ where: { event_id: eventId }, transaction });
+        await LineupPresetModel.destroy({ where: { event_id: eventId }, transaction });
+        if (botTeamIds.length > 0) {
+            const botPlayers = await PlayerTeamModel.findAll({
+                where: { team_id: botTeamIds },
+                attributes: ['player_id'],
+                transaction
+            });
+            const botPlayerIds = botPlayers.map(p => p.player_id);
+            await EventBotTeamModel.destroy({ where: { event_id: eventId }, transaction });
+            await PlayerTeamModel.destroy({ where: { team_id: botTeamIds }, transaction });
+            if (botPlayerIds.length > 0) {
+                await PlayerModel.destroy({ where: { player_id: botPlayerIds }, transaction });
+            }
+            await sequelize.query('DELETE FROM "Tactics" WHERE team_id IN (:ids)', {
+                replacements: { ids: botTeamIds }, type: QueryTypes.DELETE, transaction
+            });
+            await TeamModel.destroy({ where: { team_id: botTeamIds }, transaction });
+        }
+        if (removeEvent) {
+            await EventModel.destroy({ where: { event_id: eventId }, transaction });
+        }
+        else {
+            await EventModel.update({ status: 'ARCHIVED', purged_at: new Date() }, { where: { event_id: eventId }, transaction });
+        }
+    });
+    logger.info(`${removeEvent ? 'Deleted' : 'Purged'} event ${eventId}`);
+}

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

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

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

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

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

@@ -1,4 +1,4 @@
-import { AuthIdentityModel, AuthSessionModel, AuthUserModel, BoxScoreModel, CoachModel, ScoutModel, PhysicianModel, PhysiotherapistModel, BoxScoreTotalsModel, CompetitionChampionModel, CurrencyTransactionModel, GachaPityModel, GachaPullHistoryModel, WishlistModel, UserSettingsModel, UserDeviceTokenModel, CompetitionMatchModel, CompetitionMVPModel, CompetitionModel, CompetitionStandingsMatchModel, CompetitionStandingsModel, CompetitionTeamsModel, CountryModel, DivisionModel, DivisionSeasonModel, IterationModel, LeagueModel, MatchModel, MatchRatingModel, MatchResultModel, MatchSetModel, PerformanceStatsModel, PlayerModel, PlayerImprovementLogModel, PlayerDeclineLogModel, PlayerTeamModel, RetiredPlayerModel, PromotionMatchModel, FriendlyModel, RegionQualifierModel, NationalCountryModel, RallyModel, TacticsModel, LineupPresetModel, MatchPresetModel, TeamModel, TeamReplacementModel, UserCurrencyModel, UserPlayerProgressModel, UserPullGrantModel, UserTeamModel, VPERModel, NotificationModel, AppConfigModel, LegacyTeamFlagModel } from './models';
+import { AuthIdentityModel, AuthSessionModel, AuthUserModel, BoxScoreModel, CoachModel, ScoutModel, PhysicianModel, PhysiotherapistModel, BoxScoreTotalsModel, CompetitionChampionModel, CurrencyTransactionModel, GachaPityModel, GachaPullHistoryModel, WishlistModel, UserSettingsModel, UserDeviceTokenModel, CompetitionMatchModel, CompetitionMVPModel, CompetitionModel, CompetitionStandingsMatchModel, CompetitionStandingsModel, CompetitionTeamsModel, CountryModel, DivisionModel, DivisionSeasonModel, IterationModel, LeagueModel, MatchModel, MatchRatingModel, MatchResultModel, MatchSetModel, PerformanceStatsModel, PlayerModel, PlayerImprovementLogModel, PlayerDeclineLogModel, PlayerTeamModel, RetiredPlayerModel, PromotionMatchModel, FriendlyModel, RegionQualifierModel, NationalCountryModel, RallyModel, TacticsModel, LineupPresetModel, MatchPresetModel, EventModel, EventCompetitionModel, EventSquadModel, EventPackModel, EventPackPlayerModel, EventResultModel, EventBotTeamModel, TeamModel, TeamReplacementModel, UserCurrencyModel, UserPlayerProgressModel, UserPullGrantModel, UserTeamModel, VPERModel, NotificationModel, AppConfigModel, LegacyTeamFlagModel } from './models';
 export function initModels(sequelize) {
     const Coach = CoachModel.initModel(sequelize);
     const Scout = ScoutModel.initModel(sequelize);
@@ -8,6 +8,13 @@ export function initModels(sequelize) {
     const Tactics = TacticsModel.initModel(sequelize);
     const LineupPreset = LineupPresetModel.initModel(sequelize);
     const MatchPreset = MatchPresetModel.initModel(sequelize);
+    const Event = EventModel.initModel(sequelize);
+    const EventCompetition = EventCompetitionModel.initModel(sequelize);
+    const EventSquad = EventSquadModel.initModel(sequelize);
+    const EventPack = EventPackModel.initModel(sequelize);
+    const EventPackPlayer = EventPackPlayerModel.initModel(sequelize);
+    const EventResult = EventResultModel.initModel(sequelize);
+    const EventBotTeam = EventBotTeamModel.initModel(sequelize);
     const AuthUser = AuthUserModel.initModel(sequelize);
     const UserCurrency = UserCurrencyModel.initModel(sequelize);
     const UserPlayerProgress = UserPlayerProgressModel.initModel(sequelize);
@@ -226,6 +233,33 @@ export function initModels(sequelize) {
     MatchPreset.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
     MatchPreset.belongsTo(LineupPreset, { as: 'preset', foreignKey: 'preset_id' });
     LineupPreset.hasMany(MatchPreset, { as: 'MatchPresets', foreignKey: 'preset_id' });
+    // In-game events. An event owns one Competition per group plus one for the final, the entries that registered
+    // for it, the event-scoped lineup presets those entries point at, and the filler bots generated for it.
+    // Nothing here is in a default scope: only the event endpoints and the event scheduler load these.
+    Event.hasMany(EventCompetition, { as: 'EventCompetitions', foreignKey: 'event_id' });
+    EventCompetition.belongsTo(Event, { as: 'Event', foreignKey: 'event_id' });
+    EventCompetition.belongsTo(Competition, { as: 'Competition', foreignKey: 'competition_id' });
+    Competition.hasOne(EventCompetition, { as: 'EventCompetition', foreignKey: 'competition_id' });
+    // The drafted squad an entrant plays with, the packs they opened to build it, and where they finished.
+    Event.hasMany(EventSquad, { as: 'EventSquads', foreignKey: 'event_id' });
+    EventSquad.belongsTo(Event, { as: 'Event', foreignKey: 'event_id' });
+    EventSquad.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
+    Event.hasMany(EventPack, { as: 'EventPacks', foreignKey: 'event_id' });
+    EventPack.belongsTo(Event, { as: 'Event', foreignKey: 'event_id' });
+    EventPack.belongsTo(Player, { as: 'picked', foreignKey: 'picked_player_id' });
+    EventPack.hasMany(EventPackPlayer, { as: 'choices', foreignKey: 'pack_id' });
+    EventPackPlayer.belongsTo(EventPack, { as: 'pack', foreignKey: 'pack_id' });
+    EventPackPlayer.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
+    // Keyed to the entrant's REAL team, and the only event row besides Event that outlives the purge.
+    Event.hasMany(EventResult, { as: 'EventResults', foreignKey: 'event_id' });
+    EventResult.belongsTo(Event, { as: 'Event', foreignKey: 'event_id' });
+    EventResult.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
+    Team.hasMany(EventResult, { as: 'EventResults', foreignKey: 'team_id' });
+    LineupPreset.belongsTo(Event, { as: 'Event', foreignKey: 'event_id' });
+    Event.hasMany(EventBotTeam, { as: 'EventBotTeams', foreignKey: 'event_id' });
+    EventBotTeam.belongsTo(Event, { as: 'Event', foreignKey: 'event_id' });
+    EventBotTeam.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
+    Team.hasOne(EventBotTeam, { as: 'EventBotTeam', foreignKey: 'team_id' });
     Team.belongsTo(Country, { as: 'country', foreignKey: 'country_id' });
     Team.belongsToMany(Competition, {
         as: 'Competitions',
@@ -301,6 +335,13 @@ export function initModels(sequelize) {
         Tactics,
         LineupPreset,
         MatchPreset,
+        Event,
+        EventCompetition,
+        EventSquad,
+        EventPack,
+        EventPackPlayer,
+        EventResult,
+        EventBotTeam,
         UserTeam,
         UserCurrency,
         UserPlayerProgress,

package/dist/esm/src/data/models/competition.d.ts

@@ -19,7 +19,7 @@ export interface CompetitionAttributes {
     LowerPromotionMatches?: PromotionMatchAttributes[];
 }
 export type CompetitionPk = 'competition_id';
-export type CompetitionType = 'LEAGUE' | 'TOURNAMENT' | 'QUALIFIER' | 'NATIONAL';
+export type CompetitionType = 'LEAGUE' | 'TOURNAMENT' | 'QUALIFIER' | 'NATIONAL' | 'EVENT';
 export type CompetitionId = CompetitionModel[CompetitionPk];
 export type CompetitionCreationAttributes = CompetitionAttributes;
 export declare class CompetitionModel extends Model<CompetitionAttributes, CompetitionCreationAttributes> implements CompetitionAttributes {

package/dist/esm/src/data/models/competition.js

@@ -18,7 +18,7 @@ export class CompetitionModel extends Model {
                 }
             },
             type: {
-                type: DataTypes.ENUM('LEAGUE', 'TOURNAMENT', 'QUALIFIER', 'NATIONAL'),
+                type: DataTypes.ENUM('LEAGUE', 'TOURNAMENT', 'QUALIFIER', 'NATIONAL', 'EVENT'),
                 allowNull: false
             },
             status: {

package/dist/esm/src/data/models/event-bot-team.d.ts

@@ -0,0 +1,21 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { EventId, EventModel, TeamId, TeamModel } from '.';
+export interface EventBotTeamAttributes {
+    team_id: string;
+    event_id: string;
+}
+export type EventBotTeamPk = 'team_id';
+export type EventBotTeamId = EventBotTeamModel[EventBotTeamPk];
+export type EventBotTeamCreationAttributes = EventBotTeamAttributes;
+export declare class EventBotTeamModel extends Model<EventBotTeamAttributes, EventBotTeamCreationAttributes> implements EventBotTeamAttributes {
+    team_id: string;
+    event_id: string;
+    team: TeamModel;
+    getTeam: Sequelize.BelongsToGetAssociationMixin<TeamModel>;
+    setTeam: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>;
+    Event: EventModel;
+    getEvent: Sequelize.BelongsToGetAssociationMixin<EventModel>;
+    setEvent: Sequelize.BelongsToSetAssociationMixin<EventModel, EventId>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof EventBotTeamModel;
+}

package/dist/esm/src/data/models/event-bot-team.js

@@ -0,0 +1,40 @@
+import { DataTypes, Model } from 'sequelize';
+export class EventBotTeamModel extends Model {
+    static initModel(sequelize) {
+        return EventBotTeamModel.init({
+            team_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'Team',
+                    key: 'team_id'
+                }
+            },
+            event_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'Event',
+                    key: 'event_id'
+                }
+            }
+        }, {
+            sequelize,
+            tableName: 'EventBotTeam',
+            schema: 'public',
+            timestamps: false,
+            indexes: [
+                {
+                    name: 'EventBotTeam_pk',
+                    unique: true,
+                    fields: [{ name: 'team_id' }]
+                },
+                {
+                    name: 'EventBotTeam_event_id_idx',
+                    fields: [{ name: 'event_id' }]
+                }
+            ]
+        });
+    }
+}

package/dist/esm/src/data/models/event-competition.d.ts

@@ -0,0 +1,29 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { CompetitionAttributes, CompetitionId, CompetitionModel, EventId, EventModel } from '.';
+/** A group table, or the single Sunday final. */
+export type EventCompetitionStage = 'GROUP' | 'FINAL';
+export interface EventCompetitionAttributes {
+    competition_id: string;
+    event_id: string;
+    stage: EventCompetitionStage;
+    /** 0-based group number for a GROUP row; null for the FINAL. */
+    group_index: number | null;
+    Competition?: CompetitionAttributes;
+}
+export type EventCompetitionPk = 'competition_id';
+export type EventCompetitionId = EventCompetitionModel[EventCompetitionPk];
+export type EventCompetitionCreationAttributes = EventCompetitionAttributes;
+export declare class EventCompetitionModel extends Model<EventCompetitionAttributes, EventCompetitionCreationAttributes> implements EventCompetitionAttributes {
+    competition_id: string;
+    event_id: string;
+    stage: EventCompetitionStage;
+    group_index: number | null;
+    Competition: CompetitionModel;
+    getCompetition: Sequelize.BelongsToGetAssociationMixin<CompetitionModel>;
+    setCompetition: Sequelize.BelongsToSetAssociationMixin<CompetitionModel, CompetitionId>;
+    Event: EventModel;
+    getEvent: Sequelize.BelongsToGetAssociationMixin<EventModel>;
+    setEvent: Sequelize.BelongsToSetAssociationMixin<EventModel, EventId>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof EventCompetitionModel;
+}