volleyballsimtypes 0.0.491 → 0.0.492

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;
+}

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

@@ -0,0 +1,48 @@
+import { DataTypes, Model } from 'sequelize';
+export class EventCompetitionModel extends Model {
+    static initModel(sequelize) {
+        return EventCompetitionModel.init({
+            competition_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'Competition',
+                    key: 'competition_id'
+                }
+            },
+            event_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'Event',
+                    key: 'event_id'
+                }
+            },
+            stage: {
+                type: DataTypes.TEXT,
+                allowNull: false
+            },
+            group_index: {
+                type: DataTypes.INTEGER,
+                allowNull: true
+            }
+        }, {
+            sequelize,
+            tableName: 'EventCompetition',
+            schema: 'public',
+            timestamps: false,
+            indexes: [
+                {
+                    name: 'EventCompetition_pk',
+                    unique: true,
+                    fields: [{ name: 'competition_id' }]
+                },
+                {
+                    name: 'EventCompetition_event_id_idx',
+                    fields: [{ name: 'event_id' }]
+                }
+            ]
+        });
+    }
+}

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

@@ -0,0 +1,22 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { EventPackId, EventPackModel, PlayerAttributes, PlayerId, PlayerModel } from '.';
+export interface EventPackPlayerAttributes {
+    pack_id: string;
+    player_id: string;
+    player?: PlayerAttributes;
+}
+export type EventPackPlayerPk = 'pack_id' | 'player_id';
+export type EventPackPlayerId = EventPackPlayerModel[EventPackPlayerPk];
+export type EventPackPlayerCreationAttributes = EventPackPlayerAttributes;
+export declare class EventPackPlayerModel extends Model<EventPackPlayerAttributes, EventPackPlayerCreationAttributes> implements EventPackPlayerAttributes {
+    pack_id: string;
+    player_id: string;
+    pack: EventPackModel;
+    getPack: Sequelize.BelongsToGetAssociationMixin<EventPackModel>;
+    setPack: Sequelize.BelongsToSetAssociationMixin<EventPackModel, EventPackId>;
+    player: PlayerModel;
+    getPlayer: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
+    setPlayer: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof EventPackPlayerModel;
+}

package/dist/esm/src/data/models/event-pack-player.js

@@ -0,0 +1,27 @@
+import { DataTypes, Model } from 'sequelize';
+export class EventPackPlayerModel extends Model {
+    static initModel(sequelize) {
+        return EventPackPlayerModel.init({
+            pack_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: { model: 'EventPack', key: 'pack_id' }
+            },
+            player_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: { model: 'Player', key: 'player_id' }
+            }
+        }, {
+            sequelize,
+            tableName: 'EventPackPlayer',
+            schema: 'public',
+            timestamps: false,
+            indexes: [
+                { name: 'EventPackPlayer_pk', unique: true, fields: [{ name: 'pack_id' }, { name: 'player_id' }] }
+            ]
+        });
+    }
+}

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

@@ -0,0 +1,37 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import { EventId, EventModel, EventPackPlayerModel, PlayerId, PlayerModel } from '.';
+export interface EventPackAttributes {
+    pack_id: string;
+    event_id: string;
+    user_id: string;
+    /** Position in DRAFT_PLAN, so the pack's role and the draft's progress are both derivable. */
+    index: number;
+    /** The role this pack offers. A free pack stores the role it actually rolled, not 'ANY'. */
+    role: string;
+    opened_at: Date;
+    /** Null until the entrant picks; set once, and the three unpicked players are deleted at that moment. */
+    picked_player_id: string | null;
+}
+export type EventPackPk = 'pack_id';
+export type EventPackId = EventPackModel[EventPackPk];
+export type EventPackOptionalAttributes = 'pack_id' | 'opened_at' | 'picked_player_id';
+export type EventPackCreationAttributes = Optional<EventPackAttributes, EventPackOptionalAttributes>;
+export declare class EventPackModel extends Model<EventPackAttributes, EventPackCreationAttributes> implements EventPackAttributes {
+    pack_id: string;
+    event_id: string;
+    user_id: string;
+    index: number;
+    role: string;
+    opened_at: Date;
+    picked_player_id: string | null;
+    Event: EventModel;
+    getEvent: Sequelize.BelongsToGetAssociationMixin<EventModel>;
+    setEvent: Sequelize.BelongsToSetAssociationMixin<EventModel, EventId>;
+    choices: EventPackPlayerModel[];
+    getChoices: Sequelize.HasManyGetAssociationsMixin<EventPackPlayerModel>;
+    picked: PlayerModel;
+    getPicked: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
+    setPicked: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof EventPackModel;
+}

package/dist/esm/src/data/models/event-pack.js

@@ -0,0 +1,51 @@
+import { DataTypes, Model } from 'sequelize';
+export class EventPackModel extends Model {
+    static initModel(sequelize) {
+        return EventPackModel.init({
+            pack_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                defaultValue: DataTypes.UUIDV4
+            },
+            event_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                references: { model: 'Event', key: 'event_id' }
+            },
+            user_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                references: { model: 'AuthUser', key: 'user_id' }
+            },
+            index: {
+                type: DataTypes.INTEGER,
+                allowNull: false
+            },
+            role: {
+                type: DataTypes.TEXT,
+                allowNull: false
+            },
+            opened_at: {
+                type: DataTypes.DATE,
+                allowNull: false,
+                defaultValue: DataTypes.NOW
+            },
+            picked_player_id: {
+                type: DataTypes.UUID,
+                allowNull: true,
+                references: { model: 'Player', key: 'player_id' }
+            }
+        }, {
+            sequelize,
+            tableName: 'EventPack',
+            schema: 'public',
+            timestamps: false,
+            indexes: [
+                { name: 'EventPack_pk', unique: true, fields: [{ name: 'pack_id' }] },
+                // One pack per position per entrant: reopening returns the stored pack instead of generating a new one.
+                { name: 'EventPack_one_per_index', unique: true, fields: [{ name: 'event_id' }, { name: 'user_id' }, { name: 'index' }] }
+            ]
+        });
+    }
+}

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

@@ -0,0 +1,34 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import type { EventKey } from '../../service/competition/event-schedule';
+import { EventId, EventModel, TeamAttributes, TeamId, TeamModel } from '.';
+export interface EventResultAttributes {
+    event_id: string;
+    /** The user's permanent team, so their accolades page can find it. */
+    team_id: string;
+    /** Place in the FINAL table, or null for an entrant who never reached it (group stage). */
+    position: number | null;
+    entrants: number;
+    key: EventKey;
+    ended_at: Date;
+    Event?: EventModel;
+    team?: TeamAttributes;
+}
+export type EventResultPk = 'event_id' | 'team_id';
+export type EventResultId = EventResultModel[EventResultPk];
+export type EventResultCreationAttributes = EventResultAttributes;
+export declare class EventResultModel extends Model<EventResultAttributes, EventResultCreationAttributes> implements EventResultAttributes {
+    event_id: string;
+    team_id: string;
+    position: number | null;
+    entrants: number;
+    key: EventKey;
+    ended_at: Date;
+    Event: EventModel;
+    getEvent: Sequelize.BelongsToGetAssociationMixin<EventModel>;
+    setEvent: Sequelize.BelongsToSetAssociationMixin<EventModel, EventId>;
+    team: TeamModel;
+    getTeam: Sequelize.BelongsToGetAssociationMixin<TeamModel>;
+    setTeam: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof EventResultModel;
+}