volleyballsimtypes 0.0.491 → 0.0.493

package/dist/esm/src/service/competition/event-schedule.test.js

@@ -0,0 +1,136 @@
+import { describe, it, expect } from '@jest/globals';
+import { EVENT_CATALOGUE, MAX_FINAL_SIZE, MIN_GROUP_SIZE, MIN_ROUND_SPACING_MINUTES, REVIEW_DAYS, eventDefinitionForKey, eventStatusAt, eventWindowsFor, groupStageHours, planEventGroups } from './event-schedule';
+import { RarityEnum } from '../player';
+const COMMONS = eventDefinitionForKey('WAR_OF_THE_COMMONS');
+describe('EVENT_CATALOGUE', () => {
+    it('restricts the three launch presets to a single rarity each, over one week', () => {
+        expect(EVENT_CATALOGUE.map(e => e.rarity)).toEqual([RarityEnum.COMMON, RarityEnum.RARE, RarityEnum.LEGENDARY]);
+        expect(EVENT_CATALOGUE.every(e => e.durationDays === 7)).toBe(true);
+        expect(EVENT_CATALOGUE.every(e => e.format === 'GROUPS_FINAL')).toBe(true);
+    });
+    it('leaves room for a final day in every preset', () => {
+        expect(EVENT_CATALOGUE.every(e => e.durationDays >= 2)).toBe(true);
+    });
+});
+describe('eventDefinitionForKey()', () => {
+    it('reads the rules off the key an event stores', () => {
+        expect(eventDefinitionForKey('STUFF_OF_LEGENDS').rarity).toBe(RarityEnum.LEGENDARY);
+        expect(eventDefinitionForKey('RARE_GEMS').rarity).toBe(RarityEnum.RARE);
+        expect(eventDefinitionForKey('WAR_OF_THE_COMMONS').rarity).toBe(RarityEnum.COMMON);
+    });
+    it('throws on a key that is not in the catalogue', () => {
+        expect(() => eventDefinitionForKey('NOT_AN_EVENT')).toThrow('UNKNOWN_EVENT_KEY');
+    });
+});
+describe('eventWindowsFor()', () => {
+    it('derives every date from the preset, the start day and the registration lead time', () => {
+        const w = eventWindowsFor(COMMONS, new Date('2026-08-03T00:00:00.000Z'), 4);
+        expect(w.registrationOpensAt.toISOString()).toBe('2026-07-30T00:00:00.000Z'); // start - 4 days
+        expect(w.registrationClosesAt.toISOString()).toBe('2026-08-03T00:00:00.000Z'); // = startsAt
+        expect(w.startsAt.toISOString()).toBe('2026-08-03T00:00:00.000Z');
+        expect(w.finalStartsAt.toISOString()).toBe('2026-08-09T00:00:00.000Z'); // last day of 7
+        expect(w.endsAt.toISOString()).toBe('2026-08-10T00:00:00.000Z');
+        expect(w.purgeAt.toISOString()).toBe('2026-08-13T00:00:00.000Z'); // + 3 review days
+    });
+    it('floors the start to 00:00 UTC so an event always runs whole days', () => {
+        const w = eventWindowsFor(COMMONS, new Date('2026-08-03T17:42:11.000Z'), 4);
+        expect(w.startsAt.toISOString()).toBe('2026-08-03T00:00:00.000Z');
+    });
+    it('moves registration with the lead time and nothing else', () => {
+        const a = eventWindowsFor(COMMONS, new Date('2026-08-03T00:00:00.000Z'), 1);
+        const b = eventWindowsFor(COMMONS, new Date('2026-08-03T00:00:00.000Z'), 14);
+        expect(a.registrationOpensAt.toISOString()).toBe('2026-08-02T00:00:00.000Z');
+        expect(b.registrationOpensAt.toISOString()).toBe('2026-07-20T00:00:00.000Z');
+        expect(a.startsAt.getTime()).toBe(b.startsAt.getTime());
+        expect(a.endsAt.getTime()).toBe(b.endsAt.getTime());
+        expect(a.purgeAt.getTime()).toBe(b.purgeAt.getTime());
+    });
+    it('gives the final exactly one day, whatever the duration', () => {
+        for (const durationDays of [2, 3, 7, 10]) {
+            const w = eventWindowsFor({ ...COMMONS, durationDays }, new Date('2026-08-03T00:00:00.000Z'), 4);
+            expect(w.endsAt.getTime() - w.finalStartsAt.getTime()).toBe(24 * 3600 * 1000);
+            expect(w.endsAt.getTime() - w.startsAt.getTime()).toBe(durationDays * 24 * 3600 * 1000);
+            expect(w.purgeAt.getTime() - w.endsAt.getTime()).toBe(REVIEW_DAYS * 24 * 3600 * 1000);
+        }
+    });
+});
+describe('groupStageHours()', () => {
+    it('is every day before the final day', () => {
+        expect(groupStageHours({ ...COMMONS, durationDays: 7 })).toBe(144);
+        expect(groupStageHours({ ...COMMONS, durationDays: 2 })).toBe(24);
+        expect(groupStageHours({ ...COMMONS, durationDays: 10 })).toBe(216);
+    });
+});
+describe('eventStatusAt()', () => {
+    const w = eventWindowsFor(COMMONS, new Date('2026-08-03T00:00:00.000Z'), 4);
+    it.each([
+        ['2026-07-30T00:00:00.000Z', 'REGISTRATION'],
+        ['2026-08-02T23:59:59.000Z', 'REGISTRATION'],
+        ['2026-08-03T00:00:00.000Z', 'IN_PROGRESS'],
+        ['2026-08-09T12:00:00.000Z', 'IN_PROGRESS'],
+        ['2026-08-09T23:59:59.000Z', 'IN_PROGRESS'],
+        ['2026-08-10T00:00:00.000Z', 'REVIEW'],
+        ['2026-08-12T23:59:59.000Z', 'REVIEW'],
+        ['2026-08-13T00:00:00.000Z', 'ARCHIVED']
+    ])('reads %s as %s', (iso, status) => {
+        expect(eventStatusAt(w, new Date(iso))).toBe(status);
+    });
+});
+describe('planEventGroups()', () => {
+    const WEEK = groupStageHours(COMMONS); // 144h, the six days before the final
+    it.each([
+        // turnout, groups, size, qualifiers/group, final. Tiers: <64 = 3 groups top 8, <96 = 4 top 6,
+        // <128 = 6 top 4, <192 = 8 top 3, otherwise 12 top 2. Every tier multiplies out to a 24-team final.
+        [1, 3, MIN_GROUP_SIZE, 8, 24],
+        [12, 3, MIN_GROUP_SIZE, 8, 24],
+        [48, 3, MIN_GROUP_SIZE, 8, 24],
+        [63, 3, 22, 8, 24],
+        [64, 4, MIN_GROUP_SIZE, 6, 24],
+        [95, 4, 24, 6, 24],
+        [96, 6, MIN_GROUP_SIZE, 4, 24],
+        [127, 6, 22, 4, 24],
+        [128, 8, MIN_GROUP_SIZE, 3, 24],
+        [191, 8, 24, 3, 24],
+        [192, 12, MIN_GROUP_SIZE, 2, 24],
+        [300, 12, 26, 2, 24]
+    ])('splits a turnout of %i into %i groups of %i', (n, groupCount, groupSize, qualifiersPerGroup, finalSize) => {
+        const plan = planEventGroups(n, WEEK);
+        expect(plan.groupCount).toBe(groupCount);
+        expect(plan.groupSize).toBe(groupSize);
+        expect(plan.qualifiersPerGroup).toBe(qualifiersPerGroup);
+        expect(plan.finalSize).toBe(finalSize);
+        expect(plan.botCount).toBe(groupCount * groupSize - n);
+    });
+    it.each([1, 2, 7, 12, 33, 40, 41, 60, 61, 99, 100, 137, 250, 500])('keeps every group even, bot-padded and inside the final cap for a turnout of %i', (n) => {
+        const plan = planEventGroups(n, WEEK);
+        expect(plan.groupSize % 2).toBe(0); // even, so nobody sits a group-stage round out
+        expect(plan.groupSize).toBeGreaterThanOrEqual(MIN_GROUP_SIZE);
+        expect([3, 4, 6, 8, 12]).toContain(plan.groupCount);
+        expect(plan.botCount).toBeGreaterThanOrEqual(0);
+        expect(plan.groupCount * plan.groupSize).toBe(n + plan.botCount);
+        // Every tier is built to fill the final exactly, however many entered.
+        expect(plan.finalSize).toBe(MAX_FINAL_SIZE);
+        expect(plan.finalSize % 2).toBe(0); // an odd final would leave a team without an opponent every round
+        expect(plan.qualifiersPerGroup).toBeLessThanOrEqual(plan.groupSize);
+        expect(plan.groupRoundSpacingMinutes).toBeGreaterThanOrEqual(MIN_ROUND_SPACING_MINUTES);
+        // Rounds start on the hour or the half hour, never at 19:12.
+        expect(plan.groupRoundSpacingMinutes % 30).toBe(0);
+    });
+    it('fits the whole round robin inside the group-stage window until it genuinely cannot', () => {
+        for (const n of [1, 40, 100, 250, 700]) {
+            const plan = planEventGroups(n, WEEK);
+            expect(plan.overflows).toBe(false);
+            expect((plan.groupSize - 1) * plan.groupRoundSpacingMinutes).toBeLessThanOrEqual(WEEK * 60);
+        }
+        // 12 groups of 168 needs 167 rounds; at the one-hour minimum that is far more than six days, so the plan
+        // reports the overflow instead of silently generating a schedule that runs past the deadline.
+        expect(planEventGroups(2000, WEEK).overflows).toBe(true);
+    });
+    it('paces rounds to the window it is given, so a shorter event packs them tighter', () => {
+        const long = planEventGroups(40, WEEK);
+        const short = planEventGroups(40, groupStageHours({ ...COMMONS, durationDays: 3 })); // 48h
+        expect(short.groupSize).toBe(long.groupSize);
+        expect(short.groupRoundSpacingMinutes).toBeLessThan(long.groupRoundSpacingMinutes);
+        expect((short.groupSize - 1) * short.groupRoundSpacingMinutes).toBeLessThanOrEqual(48 * 60);
+    });
+});

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

@@ -1,5 +1,8 @@
 export * from './standing';
 export * from './season';
+export * from './event-schedule';
+export * from './event-draft';
+export * from './event-rewards';
 export * from './league';
 export * from './division';
 export * from './iteration';

package/dist/esm/src/service/competition/index.js

@@ -1,5 +1,8 @@
 export * from './standing';
 export * from './season';
+export * from './event-schedule';
+export * from './event-draft';
+export * from './event-rewards';
 export * from './league';
 export * from './division';
 export * from './iteration';

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

@@ -4,6 +4,7 @@ export * from './match-generator';
 export * from './match-rating';
 export * from './match-set';
 export * from './rally';
+export * from './round-robin';
 export * from './point-breakdown';
 export * from './rally-metrics';
 export * from './court-position';

package/dist/esm/src/service/match/index.js

@@ -4,6 +4,7 @@ export * from './match-generator';
 export * from './match-rating';
 export * from './match-set';
 export * from './rally';
+export * from './round-robin';
 export * from './point-breakdown';
 export * from './rally-metrics';
 export * from './court-position';

package/dist/esm/src/service/match/match-generator.js

@@ -2,9 +2,13 @@ import dayjs from 'dayjs';
 import utc from 'dayjs/plugin/utc';
 import { v4 as uuidv4 } from 'uuid';
 import { Match } from './match';
+import { roundRobinRounds } from './round-robin';
 import { shuffle } from '../utils';
 import { StatusEnum } from '../../data';
 dayjs.extend(utc);
+// Consecutive matches in a league season start half an hour apart, so a 16-team double round robin (240 matches)
+// spans five days from the iteration's Monday.
+const MATCH_SPACING_MINUTES = 30;
 // eslint-disable-next-line @typescript-eslint/no-extraneous-class
 export default class MatchGenerator {
     static generateMatches(teams, baseDate) {
@@ -16,57 +20,30 @@ export default class MatchGenerator {
         if (t.size !== teams.length) {
             throw new Error('DUPLICATE_TEAMS');
         }
-        let shuffled = shuffle([...teams]);
-        const l = shuffled.length - 1;
-        const half = Math.ceil(shuffled.length / 2);
-        const matches = [];
-        // We fix the first team
-        let firstTeam = shuffled.shift();
-        if (firstTeam == null) {
+        if (teams.length < 1) {
             throw new Error('EMPTY_TEAM_ARRAY');
         }
-        let homeRow;
-        let awayRow;
-        for (let i = 0; i < l; i++) {
-            // split array in 2 halves
-            const row1 = shuffled.slice(0, half);
-            const row2 = shuffled.slice(half);
-            row2.push(firstTeam);
-            if (i % 2 === 0) {
-                homeRow = row1;
-                awayRow = row2;
-            }
-            else {
-                homeRow = row2;
-                awayRow = row1;
-            }
-            for (let j = 0; j < half; j++) {
-                matches.push(Match.create({
-                    id: uuidv4(),
-                    homeTeam: homeRow[j],
-                    awayTeam: awayRow[j],
-                    scheduledDate: date.toDate(),
-                    status: StatusEnum.PENDING
-                }));
-                date = date.add(30, 'minutes');
-            }
-            firstTeam = row2.pop();
-            row1.unshift(row2.shift());
-            row2.push(row1.pop());
-            shuffled = [...row1, ...row2];
-        }
-        // Generate Inverted matches for home-away pairings
-        matches.push(...matches.map(match => {
+        const nextDate = () => {
             const scheduledDate = date.toDate();
-            date = date.add(30, 'minutes');
-            return Match.create({
-                id: uuidv4(),
-                homeTeam: match.awayTeam,
-                awayTeam: match.homeTeam,
-                scheduledDate,
-                status: StatusEnum.PENDING
-            });
+            date = date.add(MATCH_SPACING_MINUTES, 'minutes');
+            return scheduledDate;
+        };
+        // First leg: one pass of the round robin, matches laid out back to back in round order.
+        const firstLeg = roundRobinRounds(shuffle([...teams])).flat().map(([homeTeam, awayTeam]) => Match.create({
+            id: uuidv4(),
+            homeTeam,
+            awayTeam,
+            scheduledDate: nextDate(),
+            status: StatusEnum.PENDING
+        }));
+        // Second leg: the same fixtures with the sides swapped, so every pairing is played home and away.
+        const secondLeg = firstLeg.map(match => Match.create({
+            id: uuidv4(),
+            homeTeam: match.awayTeam,
+            awayTeam: match.homeTeam,
+            scheduledDate: nextDate(),
+            status: StatusEnum.PENDING
         }));
-        return matches;
+        return [...firstLeg, ...secondLeg];
     }
 }

package/dist/esm/src/service/match/match-generator.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/src/service/match/match-generator.test.js

@@ -0,0 +1,43 @@
+import { describe, it, expect } from '@jest/globals';
+import MatchGenerator from './match-generator';
+import { makeTeam } from '../test-helpers';
+// The league season schedule. These assertions pin the behaviour the rollover depends on, so the shared
+// roundRobinRounds helper (used by events too) cannot silently change how a season is laid out.
+const MONDAY = new Date('2026-07-20T00:00:00.000Z');
+function orderedKey(match) {
+    return `${match.homeTeam.id}>${match.awayTeam.id}`;
+}
+describe('MatchGenerator.generateMatches()', () => {
+    it('plays a full double round robin for a 16-team division', () => {
+        const teams = Array.from({ length: 16 }, () => makeTeam());
+        const matches = MatchGenerator.generateMatches(teams, MONDAY);
+        // 16 teams x 15 opponents, home and away.
+        expect(matches).toHaveLength(240);
+        const seen = new Set(matches.map(orderedKey));
+        expect(seen.size).toBe(240);
+        // Every ordered pairing exists exactly once, so every team hosts and visits every other team.
+        for (const home of teams) {
+            for (const away of teams) {
+                if (home.id === away.id)
+                    continue;
+                expect(seen.has(`${home.id}>${away.id}`)).toBe(true);
+            }
+        }
+    });
+    it('anchors to 00:00 UTC of the base day and spaces matches 30 minutes apart', () => {
+        const teams = Array.from({ length: 16 }, () => makeTeam());
+        const matches = MatchGenerator.generateMatches(teams, new Date('2026-07-20T17:42:11.000Z'));
+        const times = matches.map(m => m.scheduledDate.getTime()).sort((a, b) => a - b);
+        expect(new Date(times[0]).toISOString()).toBe('2026-07-20T00:00:00.000Z');
+        for (let i = 1; i < times.length; i++) {
+            expect(times[i] - times[i - 1]).toBe(30 * 60 * 1000);
+        }
+        // 240 matches at half-hour spacing = five days, ending Friday 23:30 UTC.
+        expect(new Date(times[times.length - 1]).toISOString()).toBe('2026-07-24T23:30:00.000Z');
+    });
+    it('rejects a duplicated team and an empty division', () => {
+        const team = makeTeam();
+        expect(() => MatchGenerator.generateMatches([team, team], MONDAY)).toThrow('DUPLICATE_TEAMS');
+        expect(() => MatchGenerator.generateMatches([], MONDAY)).toThrow('EMPTY_TEAM_ARRAY');
+    });
+});

package/dist/esm/src/service/match/round-robin.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Circle-method single round robin. Returns one entry per round, each holding the pairings that round plays,
+ * as `[home, away]` tuples. Every unordered pair of entrants appears exactly once across all rounds.
+ *
+ * An ODD entrant count produces a bye: one entrant sits out each round, so a round has `floor(n / 2)` pairings
+ * instead of `n / 2`. Callers that need everyone playing every round must pad to an even count first.
+ *
+ * Home and away alternate by round and by court index, so no entrant ends up at home in all of its games. For a
+ * double round robin the caller replays the same rounds with the sides swapped, which balances them exactly.
+ */
+export declare function roundRobinRounds<T>(entrants: T[]): Array<Array<[T, T]>>;

package/dist/esm/src/service/match/round-robin.js

@@ -0,0 +1,41 @@
+// A bye slot, used to keep the circle even when an odd number of entrants is passed. Pairings that involve it
+// are dropped, so that entrant sits the round out. Module-level so the type is nameable inside the function.
+const BYE = Symbol('ROUND_ROBIN_BYE');
+/**
+ * Circle-method single round robin. Returns one entry per round, each holding the pairings that round plays,
+ * as `[home, away]` tuples. Every unordered pair of entrants appears exactly once across all rounds.
+ *
+ * An ODD entrant count produces a bye: one entrant sits out each round, so a round has `floor(n / 2)` pairings
+ * instead of `n / 2`. Callers that need everyone playing every round must pad to an even count first.
+ *
+ * Home and away alternate by round and by court index, so no entrant ends up at home in all of its games. For a
+ * double round robin the caller replays the same rounds with the sides swapped, which balances them exactly.
+ */
+export function roundRobinRounds(entrants) {
+    if (entrants.length < 2)
+        return [];
+    const wheel = entrants.length % 2 === 0 ? [...entrants] : [...entrants, BYE];
+    const size = wheel.length;
+    const half = size / 2;
+    const rounds = [];
+    // Index 0 stays put while the rest rotate one place per round; pairing i against size-1-i then yields every
+    // pair exactly once over size-1 rounds.
+    let circle = wheel;
+    for (let round = 0; round < size - 1; round++) {
+        const pairings = [];
+        for (let court = 0; court < half; court++) {
+            const a = circle[court];
+            const b = circle[size - 1 - court];
+            if (a === BYE || b === BYE)
+                continue;
+            // Flip the whole column every other round. A rotating entrant advances one place per round, so it spends
+            // consecutive rounds on the same side of the circle and this parity alternates its home/away within them.
+            // Folding the court index into the parity instead would keep it CONSTANT for that entrant (its index and
+            // the round number rise together), pinning some entrants to one side for the entire event.
+            pairings.push(round % 2 === 0 ? [a, b] : [b, a]);
+        }
+        rounds.push(pairings);
+        circle = [circle[0], circle[size - 1], ...circle.slice(1, size - 1)];
+    }
+    return rounds;
+}

package/dist/esm/src/service/match/round-robin.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/src/service/match/round-robin.test.js

@@ -0,0 +1,69 @@
+import { roundRobinRounds } from './round-robin';
+function key(a, b) {
+    return a < b ? `${a}:${b}` : `${b}:${a}`;
+}
+function entrants(n) {
+    return Array.from({ length: n }, (_, i) => `t${i}`);
+}
+describe('roundRobinRounds()', () => {
+    it('returns nothing for fewer than two entrants', () => {
+        expect(roundRobinRounds([])).toEqual([]);
+        expect(roundRobinRounds(['solo'])).toEqual([]);
+    });
+    it.each([2, 4, 6, 8, 16, 20, 50])('pairs every even field of %i exactly once', (n) => {
+        const rounds = roundRobinRounds(entrants(n));
+        expect(rounds).toHaveLength(n - 1);
+        rounds.forEach(round => expect(round).toHaveLength(n / 2));
+        const seen = new Set();
+        for (const round of rounds) {
+            // Nobody plays twice in the same round.
+            const playing = new Set();
+            for (const [home, away] of round) {
+                expect(home).not.toEqual(away);
+                expect(playing.has(home)).toBe(false);
+                expect(playing.has(away)).toBe(false);
+                playing.add(home);
+                playing.add(away);
+                const k = key(home, away);
+                expect(seen.has(k)).toBe(false);
+                seen.add(k);
+            }
+            expect(playing.size).toBe(n);
+        }
+        expect(seen.size).toBe((n * (n - 1)) / 2);
+    });
+    it.each([3, 5, 7, 15])('gives an odd field of %i one bye per round and still pairs everyone once', (n) => {
+        const rounds = roundRobinRounds(entrants(n));
+        // An odd field runs the even-sized circle it was padded into: n rounds, one entrant idle in each.
+        expect(rounds).toHaveLength(n);
+        rounds.forEach(round => expect(round).toHaveLength((n - 1) / 2));
+        const seen = new Set();
+        const byes = new Map();
+        for (const round of rounds) {
+            const playing = new Set();
+            for (const [home, away] of round) {
+                seen.add(key(home, away));
+                playing.add(home);
+                playing.add(away);
+            }
+            const idle = entrants(n).filter(t => !playing.has(t));
+            expect(idle).toHaveLength(1);
+            byes.set(idle[0], (byes.get(idle[0]) ?? 0) + 1);
+        }
+        expect(seen.size).toBe((n * (n - 1)) / 2);
+        // Exactly one bye each: nobody sits out twice while another entrant never rests.
+        expect([...byes.values()]).toEqual(Array.from({ length: n }, () => 1));
+    });
+    it.each([8, 16, 20, 50])('splits home and away near evenly across a field of %i', (n) => {
+        const homeCounts = new Map();
+        for (const round of roundRobinRounds(entrants(n))) {
+            for (const [home] of round)
+                homeCounts.set(home, (homeCounts.get(home) ?? 0) + 1);
+        }
+        // n-1 games each, so half of them is the ideal. Folding the court index into the side parity used to pin
+        // some entrants to a single side for the whole event; this guards that regression.
+        for (const t of entrants(n)) {
+            expect(Math.abs((homeCounts.get(t) ?? 0) - (n - 1) / 2)).toBeLessThanOrEqual(2);
+        }
+    });
+});

package/dist/esm/src/service/notification/catalog/en.json

@@ -37,5 +37,26 @@
     "generic": {
         "title": "World Aces",
         "body": "You have a new notification."
+    },
+    "eventRegistrationOpen": {
+        "title": "Event registration open",
+        "body": "A new event is open. Draft your squad from the packs before registration closes."
+    },
+    "eventRegistrationClosing": {
+        "title": "Registration closes soon",
+        "body": "Registration for the event closes in an hour. Draft your squad to take part."
+    },
+    "eventStarted": {
+        "title": "Event started",
+        "body": "Your event matches have begun. Good luck!"
+    },
+    "eventFinalRound": {
+        "title": "You reached the final",
+        "body": "You qualified for the final round. It starts now."
+    },
+    "eventFinished": {
+        "title": "Event finished",
+        "body": "The event is over. See the final table and your rewards.",
+        "placed": "The event is over. You finished {{position}} of {{entrants}}."
     }
 }

package/dist/esm/src/service/notification/catalog/es.json

@@ -37,5 +37,26 @@
     "generic": {
         "title": "World Aces",
         "body": "Tienes una nueva notificación."
+    },
+    "eventRegistrationOpen": {
+        "title": "Inscripciones abiertas",
+        "body": "Hay un nuevo evento abierto. Arma tu plantilla con los sobres antes de que cierren las inscripciones."
+    },
+    "eventRegistrationClosing": {
+        "title": "Las inscripciones cierran pronto",
+        "body": "Las inscripciones del evento cierran en una hora. Arma tu plantilla para participar."
+    },
+    "eventStarted": {
+        "title": "El evento ha empezado",
+        "body": "Tus partidos del evento han comenzado. ¡Suerte!"
+    },
+    "eventFinalRound": {
+        "title": "Has llegado a la final",
+        "body": "Te has clasificado para la ronda final. Empieza ahora."
+    },
+    "eventFinished": {
+        "title": "Evento terminado",
+        "body": "El evento ha terminado. Mira la tabla final y tus recompensas.",
+        "placed": "El evento ha terminado. Has quedado {{position}} de {{entrants}}."
     }
 }

package/dist/esm/src/service/notification/catalog/fr.json

@@ -37,5 +37,26 @@
     "generic": {
         "title": "World Aces",
         "body": "Vous avez une nouvelle notification."
+    },
+    "eventRegistrationOpen": {
+        "title": "Inscriptions ouvertes",
+        "body": "Un nouvel événement est ouvert. Compose ton effectif avec les packs avant la clôture des inscriptions."
+    },
+    "eventRegistrationClosing": {
+        "title": "Les inscriptions ferment bientôt",
+        "body": "Les inscriptions à l'événement ferment dans une heure. Compose ton effectif pour participer."
+    },
+    "eventStarted": {
+        "title": "L'événement a commencé",
+        "body": "Tes matchs ont commencé. Bonne chance !"
+    },
+    "eventFinalRound": {
+        "title": "Tu es en finale",
+        "body": "Tu es qualifié pour la finale. Elle commence maintenant."
+    },
+    "eventFinished": {
+        "title": "Événement terminé",
+        "body": "L'événement est terminé. Consulte le classement final et tes récompenses.",
+        "placed": "L'événement est terminé. Tu finis {{position}} sur {{entrants}}."
     }
 }

package/dist/esm/src/service/notification/catalog/it.json

@@ -37,5 +37,26 @@
     "generic": {
         "title": "World Aces",
         "body": "Hai una nuova notifica."
+    },
+    "eventRegistrationOpen": {
+        "title": "Iscrizioni aperte",
+        "body": "Un nuovo evento è aperto. Costruisci la rosa dai pacchetti prima che chiudano le iscrizioni."
+    },
+    "eventRegistrationClosing": {
+        "title": "Le iscrizioni stanno per chiudere",
+        "body": "Le iscrizioni all'evento chiudono tra un'ora. Costruisci la rosa per partecipare."
+    },
+    "eventStarted": {
+        "title": "L'evento è iniziato",
+        "body": "Le tue partite sono iniziate. In bocca al lupo!"
+    },
+    "eventFinalRound": {
+        "title": "Sei in finale",
+        "body": "Ti sei qualificato per la finale. Inizia ora."
+    },
+    "eventFinished": {
+        "title": "Evento concluso",
+        "body": "L'evento è finito. Guarda la classifica finale e i tuoi premi.",
+        "placed": "L'evento è finito. Hai chiuso {{position}} su {{entrants}}."
     }
 }

package/dist/esm/src/service/notification/catalog/pl.json

@@ -37,5 +37,26 @@
     "generic": {
         "title": "World Aces",
         "body": "Masz nowe powiadomienie."
+    },
+    "eventRegistrationOpen": {
+        "title": "Zapisy otwarte",
+        "body": "Nowe wydarzenie jest otwarte. Zbuduj skład z paczek, zanim zamkną się zapisy."
+    },
+    "eventRegistrationClosing": {
+        "title": "Zapisy wkrótce się zamkną",
+        "body": "Zapisy na wydarzenie zamykają się za godzinę. Zbuduj skład, aby wziąć udział."
+    },
+    "eventStarted": {
+        "title": "Wydarzenie ruszyło",
+        "body": "Twoje mecze się rozpoczęły. Powodzenia!"
+    },
+    "eventFinalRound": {
+        "title": "Jesteś w finale",
+        "body": "Awansowałeś do rundy finałowej. Zaczyna się teraz."
+    },
+    "eventFinished": {
+        "title": "Wydarzenie zakończone",
+        "body": "Wydarzenie się skończyło. Zobacz tabelę końcową i nagrody.",
+        "placed": "Wydarzenie się skończyło. Zająłeś {{position}} miejsce na {{entrants}}."
     }
 }

package/dist/esm/src/service/notification/catalog/pt-BR.json

@@ -37,5 +37,26 @@
     "generic": {
         "title": "World Aces",
         "body": "Você tem uma nova notificação."
+    },
+    "eventRegistrationOpen": {
+        "title": "Inscrições abertas",
+        "body": "Um novo evento está aberto. Monte seu elenco com os pacotes antes das inscrições fecharem."
+    },
+    "eventRegistrationClosing": {
+        "title": "As inscrições fecham em breve",
+        "body": "As inscrições do evento fecham em uma hora. Monte seu elenco para participar."
+    },
+    "eventStarted": {
+        "title": "O evento começou",
+        "body": "Suas partidas do evento começaram. Boa sorte!"
+    },
+    "eventFinalRound": {
+        "title": "Você chegou à final",
+        "body": "Você se classificou para a rodada final. Começa agora."
+    },
+    "eventFinished": {
+        "title": "Evento encerrado",
+        "body": "O evento acabou. Veja a tabela final e suas recompensas.",
+        "placed": "O evento acabou. Você terminou em {{position}} de {{entrants}}."
     }
 }

package/dist/esm/src/service/notification/catalog/tr.json

@@ -37,5 +37,26 @@
     "generic": {
         "title": "World Aces",
         "body": "Yeni bir bildirimin var."
+    },
+    "eventRegistrationOpen": {
+        "title": "Kayıtlar açıldı",
+        "body": "Yeni bir etkinlik açıldı. Kayıtlar kapanmadan paketlerden kadronu kur."
+    },
+    "eventRegistrationClosing": {
+        "title": "Kayıtlar birazdan kapanıyor",
+        "body": "Etkinlik kayıtları bir saat içinde kapanıyor. Katılmak için kadronu kur."
+    },
+    "eventStarted": {
+        "title": "Etkinlik başladı",
+        "body": "Etkinlik maçların başladı. Bol şans!"
+    },
+    "eventFinalRound": {
+        "title": "Finale kaldın",
+        "body": "Final turuna kaldın. Şimdi başlıyor."
+    },
+    "eventFinished": {
+        "title": "Etkinlik bitti",
+        "body": "Etkinlik sona erdi. Final tablosuna ve ödüllerine bak.",
+        "placed": "Etkinlik sona erdi. {{entrants}} takım arasında {{position}}. oldun."
     }
 }

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

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