volleyballsimtypes 0.0.489 → 0.0.492

package/dist/cjs/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, CourtPosition, ConditionLogic, EnergyBand, MatchForfeitType, PerformanceStats, PinchCondition, RoleEnum, RotationSystemEnum, SubBackMode, SubBand } from '../service';
+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;
@@ -101,7 +102,7 @@ export interface ApiOffensivePreference {
 }
 export interface ApiBlockingPreference {
     rotation: number;
-    targets: Record<string, RoleEnum>;
+    targets: Record<string, BlockingAssignment>;
 }
 export interface ApiSystemSet {
     rotationSystem: RotationSystemEnum;

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

@@ -1,3 +1,18 @@
 "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 });
 const service_1 = require("../service");
+__exportStar(require("./tactics-player-refs"), exports);

package/dist/cjs/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/cjs/src/api/tactics-player-refs.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectTacticsPlayerIds = collectTacticsPlayerIds;
+/**
+ * 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.
+ */
+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/cjs/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/cjs/src/data/event-purge.js

@@ -0,0 +1,116 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.purgeEvent = purgeEvent;
+const sequelize_1 = require("sequelize");
+const models_1 = require("./models");
+const logger_1 = __importDefault(require("../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.
+ */
+async function purgeEvent(sequelize, eventId, removeEvent = false) {
+    await sequelize.transaction(async (transaction) => {
+        const competitions = await models_1.EventCompetitionModel.findAll({
+            where: { event_id: eventId },
+            attributes: ['competition_id'],
+            transaction
+        });
+        const competitionIds = competitions.map(c => c.competition_id);
+        const botTeams = await models_1.EventBotTeamModel.findAll({
+            where: { event_id: eventId },
+            attributes: ['team_id'],
+            transaction
+        });
+        const squads = await models_1.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 models_1.CompetitionMatchModel.findAll({
+                where: { competition_id: competitionIds },
+                attributes: ['match_id'],
+                transaction
+            });
+            const matchIds = matchRows.map(m => m.match_id);
+            if (matchIds.length > 0) {
+                await models_1.MatchResultModel.destroy({ where: { match_id: matchIds }, transaction });
+                await models_1.CompetitionMatchModel.destroy({ where: { competition_id: competitionIds }, transaction });
+                await models_1.MatchModel.destroy({ where: { match_id: matchIds }, transaction });
+            }
+            await models_1.CompetitionStandingsModel.destroy({ where: { competition_id: competitionIds }, transaction });
+            await sequelize.query('DELETE FROM "CompetitionStandingsMatch" WHERE competition_id IN (:ids)', {
+                replacements: { ids: competitionIds }, type: sequelize_1.QueryTypes.DELETE, transaction
+            });
+            await models_1.CompetitionTeamsModel.destroy({ where: { competition_id: competitionIds }, transaction });
+            await models_1.EventCompetitionModel.destroy({ where: { event_id: eventId }, transaction });
+            await models_1.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 models_1.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 models_1.EventPackPlayerModel.findAll({
+                where: { pack_id: packIds },
+                attributes: ['player_id'],
+                transaction
+            });
+            await models_1.EventPackPlayerModel.destroy({ where: { pack_id: packIds }, transaction });
+            await models_1.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 models_1.PlayerTeamModel.destroy({ where: { player_id: looseIds }, transaction });
+                await models_1.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 models_1.EventSquadModel.destroy({ where: { event_id: eventId }, transaction });
+        await models_1.LineupPresetModel.destroy({ where: { event_id: eventId }, transaction });
+        if (botTeamIds.length > 0) {
+            const botPlayers = await models_1.PlayerTeamModel.findAll({
+                where: { team_id: botTeamIds },
+                attributes: ['player_id'],
+                transaction
+            });
+            const botPlayerIds = botPlayers.map(p => p.player_id);
+            await models_1.EventBotTeamModel.destroy({ where: { event_id: eventId }, transaction });
+            await models_1.PlayerTeamModel.destroy({ where: { team_id: botTeamIds }, transaction });
+            if (botPlayerIds.length > 0) {
+                await models_1.PlayerModel.destroy({ where: { player_id: botPlayerIds }, transaction });
+            }
+            await sequelize.query('DELETE FROM "Tactics" WHERE team_id IN (:ids)', {
+                replacements: { ids: botTeamIds }, type: sequelize_1.QueryTypes.DELETE, transaction
+            });
+            await models_1.TeamModel.destroy({ where: { team_id: botTeamIds }, transaction });
+        }
+        if (removeEvent) {
+            await models_1.EventModel.destroy({ where: { event_id: eventId }, transaction });
+        }
+        else {
+            await models_1.EventModel.update({ status: 'ARCHIVED', purged_at: new Date() }, { where: { event_id: eventId }, transaction });
+        }
+    });
+    logger_1.default.info(`${removeEvent ? 'Deleted' : 'Purged'} event ${eventId}`);
+}

package/dist/cjs/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/cjs/src/data/index.js

@@ -18,5 +18,6 @@ exports.initModels = void 0;
 __exportStar(require("./models"), exports);
 __exportStar(require("./transformers"), exports);
 __exportStar(require("./common"), exports);
+__exportStar(require("./event-purge"), 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.js

@@ -11,6 +11,13 @@ function initModels(sequelize) {
     const Tactics = models_1.TacticsModel.initModel(sequelize);
     const LineupPreset = models_1.LineupPresetModel.initModel(sequelize);
     const MatchPreset = models_1.MatchPresetModel.initModel(sequelize);
+    const Event = models_1.EventModel.initModel(sequelize);
+    const EventCompetition = models_1.EventCompetitionModel.initModel(sequelize);
+    const EventSquad = models_1.EventSquadModel.initModel(sequelize);
+    const EventPack = models_1.EventPackModel.initModel(sequelize);
+    const EventPackPlayer = models_1.EventPackPlayerModel.initModel(sequelize);
+    const EventResult = models_1.EventResultModel.initModel(sequelize);
+    const EventBotTeam = models_1.EventBotTeamModel.initModel(sequelize);
     const AuthUser = models_1.AuthUserModel.initModel(sequelize);
     const UserCurrency = models_1.UserCurrencyModel.initModel(sequelize);
     const UserPlayerProgress = models_1.UserPlayerProgressModel.initModel(sequelize);
@@ -229,6 +236,33 @@ 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',
@@ -304,6 +338,13 @@ function initModels(sequelize) {
         Tactics,
         LineupPreset,
         MatchPreset,
+        Event,
+        EventCompetition,
+        EventSquad,
+        EventPack,
+        EventPackPlayer,
+        EventResult,
+        EventBotTeam,
         UserTeam,
         UserCurrency,
         UserPlayerProgress,

package/dist/cjs/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/cjs/src/data/models/competition.js

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

package/dist/cjs/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/cjs/src/data/models/event-bot-team.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventBotTeamModel = void 0;
+const sequelize_1 = require("sequelize");
+class EventBotTeamModel extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return EventBotTeamModel.init({
+            team_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'Team',
+                    key: 'team_id'
+                }
+            },
+            event_id: {
+                type: sequelize_1.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' }]
+                }
+            ]
+        });
+    }
+}
+exports.EventBotTeamModel = EventBotTeamModel;

package/dist/cjs/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/cjs/src/data/models/event-competition.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventCompetitionModel = void 0;
+const sequelize_1 = require("sequelize");
+class EventCompetitionModel extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return EventCompetitionModel.init({
+            competition_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'Competition',
+                    key: 'competition_id'
+                }
+            },
+            event_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'Event',
+                    key: 'event_id'
+                }
+            },
+            stage: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false
+            },
+            group_index: {
+                type: sequelize_1.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' }]
+                }
+            ]
+        });
+    }
+}
+exports.EventCompetitionModel = EventCompetitionModel;

package/dist/cjs/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/cjs/src/data/models/event-pack-player.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventPackPlayerModel = void 0;
+const sequelize_1 = require("sequelize");
+class EventPackPlayerModel extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return EventPackPlayerModel.init({
+            pack_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: { model: 'EventPack', key: 'pack_id' }
+            },
+            player_id: {
+                type: sequelize_1.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' }] }
+            ]
+        });
+    }
+}
+exports.EventPackPlayerModel = EventPackPlayerModel;

package/dist/cjs/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/cjs/src/data/models/event-pack.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventPackModel = void 0;
+const sequelize_1 = require("sequelize");
+class EventPackModel extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return EventPackModel.init({
+            pack_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                defaultValue: sequelize_1.DataTypes.UUIDV4
+            },
+            event_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: { model: 'Event', key: 'event_id' }
+            },
+            user_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: { model: 'AuthUser', key: 'user_id' }
+            },
+            index: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false
+            },
+            role: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false
+            },
+            opened_at: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: sequelize_1.DataTypes.NOW
+            },
+            picked_player_id: {
+                type: sequelize_1.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' }] }
+            ]
+        });
+    }
+}
+exports.EventPackModel = EventPackModel;