volleyballsimtypes 0.0.491 → 0.0.493

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

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

@@ -0,0 +1,44 @@
+import { DataTypes, Model } from 'sequelize';
+export class EventResultModel extends Model {
+    static initModel(sequelize) {
+        return EventResultModel.init({
+            event_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: { model: 'Event', key: 'event_id' }
+            },
+            team_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: { model: 'Team', key: 'team_id' }
+            },
+            position: {
+                type: DataTypes.INTEGER,
+                allowNull: true
+            },
+            entrants: {
+                type: DataTypes.INTEGER,
+                allowNull: false
+            },
+            key: {
+                type: DataTypes.TEXT,
+                allowNull: false
+            },
+            ended_at: {
+                type: DataTypes.DATE,
+                allowNull: false
+            }
+        }, {
+            sequelize,
+            tableName: 'EventResult',
+            schema: 'public',
+            timestamps: false,
+            indexes: [
+                { name: 'EventResult_pk', unique: true, fields: [{ name: 'event_id' }, { name: 'team_id' }] },
+                { name: 'EventResult_team_id_idx', fields: [{ name: 'team_id' }] }
+            ]
+        });
+    }
+}

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

@@ -0,0 +1,30 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import { EventId, EventModel, TeamAttributes, TeamId, TeamModel } from '.';
+export interface EventSquadAttributes {
+    event_id: string;
+    user_id: string;
+    /** The throwaway Team (active = false) holding the drafted players. Deleted at purge. */
+    team_id: string;
+    complete: boolean;
+    drafted_at: Date | null;
+    team?: TeamAttributes;
+}
+export type EventSquadPk = 'event_id' | 'user_id';
+export type EventSquadId = EventSquadModel[EventSquadPk];
+export type EventSquadOptionalAttributes = 'complete' | 'drafted_at';
+export type EventSquadCreationAttributes = Optional<EventSquadAttributes, EventSquadOptionalAttributes>;
+export declare class EventSquadModel extends Model<EventSquadAttributes, EventSquadCreationAttributes> implements EventSquadAttributes {
+    event_id: string;
+    user_id: string;
+    team_id: string;
+    complete: boolean;
+    drafted_at: Date | null;
+    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 EventSquadModel;
+}

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

@@ -0,0 +1,42 @@
+import { DataTypes, Model } from 'sequelize';
+export class EventSquadModel extends Model {
+    static initModel(sequelize) {
+        return EventSquadModel.init({
+            event_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: { model: 'Event', key: 'event_id' }
+            },
+            user_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: { model: 'AuthUser', key: 'user_id' }
+            },
+            team_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                references: { model: 'Team', key: 'team_id' }
+            },
+            complete: {
+                type: DataTypes.BOOLEAN,
+                allowNull: false,
+                defaultValue: false
+            },
+            drafted_at: {
+                type: DataTypes.DATE,
+                allowNull: true
+            }
+        }, {
+            sequelize,
+            tableName: 'EventSquad',
+            schema: 'public',
+            timestamps: false,
+            indexes: [
+                { name: 'EventSquad_pk', unique: true, fields: [{ name: 'event_id' }, { name: 'user_id' }] },
+                { name: 'EventSquad_team_id_idx', fields: [{ name: 'team_id' }] }
+            ]
+        });
+    }
+}

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

@@ -0,0 +1,51 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { EventFormat, EventKey, EventStatus } from '../../service/competition/event-schedule';
+import { EventCompetitionAttributes, EventCompetitionModel, EventSquadAttributes, EventSquadModel } from '.';
+export interface EventAttributes {
+    event_id: string;
+    key: EventKey;
+    format: EventFormat;
+    /** The rarity every player in an entrant's lineup must be. */
+    restriction: string;
+    status: EventStatus;
+    registration_opens_at: Date;
+    registration_closes_at: Date;
+    starts_at: Date;
+    final_starts_at: Date;
+    ends_at: Date;
+    purge_at: Date;
+    /** Set when the event's data was deleted; null while it still has competitions and matches. */
+    purged_at: Date | null;
+    /**
+     * Which of this event's notifications have already gone out, keyed by notification type. The tick runs every
+     * ~60 seconds, so without a marker every phase transition would re-send on every pass.
+     */
+    notified: Record<string, boolean>;
+    EventCompetitions?: EventCompetitionAttributes[];
+    EventSquads?: EventSquadAttributes[];
+}
+export type EventPk = 'event_id';
+export type EventId = EventModel[EventPk];
+export type EventOptionalAttributes = 'event_id' | 'purged_at' | 'notified';
+export type EventCreationAttributes = Optional<EventAttributes, EventOptionalAttributes>;
+export declare class EventModel extends Model<EventAttributes, EventCreationAttributes> implements EventAttributes {
+    event_id: string;
+    key: EventKey;
+    format: EventFormat;
+    restriction: string;
+    status: EventStatus;
+    registration_opens_at: Date;
+    registration_closes_at: Date;
+    starts_at: Date;
+    final_starts_at: Date;
+    ends_at: Date;
+    purge_at: Date;
+    purged_at: Date | null;
+    notified: Record<string, boolean>;
+    EventCompetitions: EventCompetitionModel[];
+    getEventCompetitions: Sequelize.HasManyGetAssociationsMixin<EventCompetitionModel>;
+    EventSquads: EventSquadModel[];
+    getEventSquads: Sequelize.HasManyGetAssociationsMixin<EventSquadModel>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof EventModel;
+}

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

@@ -0,0 +1,78 @@
+import { DataTypes, Model } from 'sequelize';
+export class EventModel extends Model {
+    static initModel(sequelize) {
+        return EventModel.init({
+            event_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                defaultValue: DataTypes.UUIDV4
+            },
+            key: {
+                type: DataTypes.TEXT,
+                allowNull: false
+            },
+            format: {
+                type: DataTypes.TEXT,
+                allowNull: false
+            },
+            restriction: {
+                type: DataTypes.TEXT,
+                allowNull: false
+            },
+            status: {
+                type: DataTypes.TEXT,
+                allowNull: false
+            },
+            registration_opens_at: {
+                type: DataTypes.DATE,
+                allowNull: false
+            },
+            registration_closes_at: {
+                type: DataTypes.DATE,
+                allowNull: false
+            },
+            starts_at: {
+                type: DataTypes.DATE,
+                allowNull: false
+            },
+            final_starts_at: {
+                type: DataTypes.DATE,
+                allowNull: false
+            },
+            ends_at: {
+                type: DataTypes.DATE,
+                allowNull: false
+            },
+            purge_at: {
+                type: DataTypes.DATE,
+                allowNull: false
+            },
+            purged_at: {
+                type: DataTypes.DATE,
+                allowNull: true
+            },
+            notified: {
+                type: DataTypes.JSONB,
+                allowNull: false,
+                defaultValue: {}
+            }
+        }, {
+            sequelize,
+            tableName: 'Event',
+            schema: 'public',
+            timestamps: false,
+            indexes: [
+                {
+                    name: 'Event_pk',
+                    unique: true,
+                    fields: [{ name: 'event_id' }]
+                },
+                {
+                    name: 'Event_starts_at_idx',
+                    fields: [{ name: 'starts_at' }]
+                }
+            ]
+        });
+    }
+}

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

@@ -38,6 +38,13 @@ export * from './team';
 export * from './team-replacement';
 export * from './tactics';
 export * from './lineup-preset';
+export * from './event';
+export * from './event-competition';
+export * from './event-bot-team';
+export * from './event-squad';
+export * from './event-pack';
+export * from './event-pack-player';
+export * from './event-result';
 export * from './match-preset';
 export * from './user-currency';
 export * from './user-player-progress';

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

@@ -38,6 +38,13 @@ export * from './team';
 export * from './team-replacement';
 export * from './tactics';
 export * from './lineup-preset';
+export * from './event';
+export * from './event-competition';
+export * from './event-bot-team';
+export * from './event-squad';
+export * from './event-pack';
+export * from './event-pack-player';
+export * from './event-result';
 export * from './match-preset';
 export * from './user-currency';
 export * from './user-player-progress';

package/dist/esm/src/data/models/lineup-preset.d.ts

@@ -9,10 +9,11 @@ export interface LineupPresetAttributes {
     is_active: boolean;
     order_index: number;
     config: ApiTactics;
+    event_id: string | null;
 }
 export type LineupPresetPk = 'preset_id';
 export type LineupPresetId = LineupPresetModel[LineupPresetPk];
-export type LineupPresetOptionalAttributes = 'preset_id' | 'is_active';
+export type LineupPresetOptionalAttributes = 'preset_id' | 'is_active' | 'event_id';
 export type LineupPresetCreationAttributes = Optional<LineupPresetAttributes, LineupPresetOptionalAttributes>;
 export declare class LineupPresetModel extends Model<LineupPresetAttributes, LineupPresetCreationAttributes> implements LineupPresetAttributes {
     preset_id: string;
@@ -21,6 +22,7 @@ export declare class LineupPresetModel extends Model<LineupPresetAttributes, Lin
     is_active: boolean;
     order_index: number;
     config: ApiTactics;
+    event_id: string | null;
     team: TeamModel;
     getTeam: Sequelize.BelongsToGetAssociationMixin<TeamModel>;
     setTeam: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>;

package/dist/esm/src/data/models/lineup-preset.js

@@ -1,3 +1,4 @@
+import * as Sequelize from 'sequelize';
 import { DataTypes, Model } from 'sequelize';
 export class LineupPresetModel extends Model {
     static initModel(sequelize) {
@@ -32,6 +33,15 @@ export class LineupPresetModel extends Model {
             config: {
                 type: DataTypes.JSONB,
                 allowNull: false
+            },
+            event_id: {
+                type: DataTypes.UUID,
+                allowNull: true,
+                defaultValue: null,
+                references: {
+                    model: 'Event',
+                    key: 'event_id'
+                }
             }
         }, {
             sequelize,
@@ -60,6 +70,16 @@ export class LineupPresetModel extends Model {
                         { name: 'team_id' }
                     ],
                     where: { is_active: true }
+                },
+                {
+                    // At most one event lineup per team per event, so the save endpoint can upsert safely.
+                    name: 'LineupPreset_one_per_team_event',
+                    unique: true,
+                    fields: [
+                        { name: 'team_id' },
+                        { name: 'event_id' }
+                    ],
+                    where: { event_id: { [Sequelize.Op.ne]: null } }
                 }
             ]
         });

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

@@ -1,3 +1,4 @@
 export * from './service';
 export * from './data';
 export * from './stat-config';
+export { collectTacticsPlayerIds } from './api/tactics-player-refs';

package/dist/esm/src/index.js

@@ -1,3 +1,7 @@
 export * from './service';
 export * from './data';
 export * from './stat-config';
+// Named rather than `export * from './api'`: the api module re-declares Tactics/Player/Team/Match as DTO
+// shapes, which would collide with the service classes of the same name at the root. Consumers that want the
+// DTO types import them from the `volleyballsimtypes/api` subpath.
+export { collectTacticsPlayerIds } from './api/tactics-player-refs';

package/dist/esm/src/service/competition/event-draft.d.ts

@@ -0,0 +1,40 @@
+import { Country } from '../country';
+import { Player, Rarity, Role } from '../player';
+/** A pack targets one role, or ANY for the single free pick at the end. */
+export type DraftRole = Role | 'ANY';
+/** How many players an opened pack offers. */
+export declare const PACK_SIZE = 4;
+/**
+ * The pack sequence, in the order they are opened. One pick each, so this is also the squad: 2 setters,
+ * 4 outsides, 3 middles, 2 opposites, 2 liberos, plus one free pick, for a squad of 14 like every other team.
+ *
+ * Role-targeted rather than free choice on purpose: it makes a positionally valid squad impossible to get
+ * wrong, so nobody drafts six liberos and then cannot field a legal lineup.
+ */
+export declare const DRAFT_PLAN: readonly DraftRole[];
+/** The size of a drafted squad: one pick per pack. */
+export declare const DRAFT_SQUAD_SIZE: number;
+/**
+ * How hard each rarity's recruits are skewed toward the top of their range when drafted in an event.
+ *
+ * Owner decision (2026-07-23): commons and rares are generated NEAR THEIR BEST, so a lower-rarity event still
+ * fields strong squads, while legendaries (and up) stay uniform, so a legendary event fields average
+ * legendaries rather than peak ones. The number is a generator skew strength (see randomIntSkewed): 0 is the
+ * plain uniform draw, and 2 was measured to land the typical common/rare recruit around the 80th percentile of
+ * its normal role-score distribution (the top fifth) while keeping real spread and never forcing a maxed
+ * player. This replaces the old reject-and-reroll fairness band: the skew lives in the generator, so the
+ * material is comparable in one draw.
+ */
+export declare const EVENT_DRAFT_TOP_SKEW: Record<Rarity, number>;
+/**
+ * The players a pack offers: `PACK_SIZE` of the pack's role at the event's rarity. The lower rarities are
+ * generated with a top-end skew (EVENT_DRAFT_TOP_SKEW) so their recruits cluster near the best; legendaries
+ * are left uniform.
+ *
+ * `pickRole` decides what an ANY pack rolls; it is passed in rather than chosen here so the caller controls the
+ * randomness (and a test can make it deterministic).
+ */
+export declare function generatePack(country: Country, rarity: Rarity, packRole: DraftRole, pickRole: (roles: readonly Role[]) => Role): Player[];
+/** The role of the pack at `index`, or undefined once the draft is complete. */
+export declare function draftPackRole(index: number): DraftRole | undefined;
+export declare function isDraftComplete(picks: number): boolean;