volleyballsimtypes 0.0.359 → 0.0.360

package/dist/cjs/src/service/team/schemas/formation.z.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormationInputSchema = void 0;
+const zod_1 = require("zod");
+const player_1 = require("../../player");
+const roleSchema = zod_1.z.enum(Object.values(player_1.RoleEnum));
+const LEFT_FRONT = 4;
+const MIDDLE_FRONT = 3;
+const RIGHT_FRONT = 2;
+const LEFT_BACK = 5;
+const MIDDLE_BACK = 6;
+const RIGHT_BACK = 1;
+const positionRoleSchema = zod_1.z.object({
+    [LEFT_FRONT]: zod_1.z.array(roleSchema).min(1),
+    [MIDDLE_FRONT]: zod_1.z.array(roleSchema).min(1),
+    [RIGHT_FRONT]: zod_1.z.array(roleSchema).min(1),
+    [LEFT_BACK]: zod_1.z.array(roleSchema).min(1),
+    [MIDDLE_BACK]: zod_1.z.array(roleSchema).min(1),
+    [RIGHT_BACK]: zod_1.z.array(roleSchema).min(1)
+});
+const subPrioritySchema = zod_1.z.object({
+    MIDDLE_BLOCKER: zod_1.z.number().int().min(1),
+    OUTSIDE_HITTER: zod_1.z.number().int().min(1),
+    OPPOSITE_HITTER: zod_1.z.number().int().min(1),
+    SETTER: zod_1.z.number().int().min(1),
+    LIBERO: zod_1.z.number().int().min(1)
+});
+exports.FormationInputSchema = zod_1.z.object({
+    name: zod_1.z.string().trim().min(1),
+    initialRotation: positionRoleSchema,
+    base: positionRoleSchema,
+    liberoSubPriority: subPrioritySchema
+});

package/dist/cjs/src/service/team/schemas/tactics.z.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { Player } from '../../player';
+export declare const TacticsInputSchema: z.ZodObject<{
+    lineup: z.ZodObject<{
+        4: z.ZodCustom<Player, Player>;
+        3: z.ZodCustom<Player, Player>;
+        2: z.ZodCustom<Player, Player>;
+        5: z.ZodCustom<Player, Player>;
+        6: z.ZodCustom<Player, Player>;
+        1: z.ZodCustom<Player, Player>;
+        0: z.ZodOptional<z.ZodCustom<Player, Player>>;
+        bench: z.ZodArray<z.ZodCustom<Player, Player>>;
+    }, z.core.$strip>;
+    substitutionTolerance: z.ZodNumber;
+    liberoReplacements: z.ZodArray<z.ZodCustom<Player, Player>>;
+    pinchServerSubs: z.ZodCustom<Map<Player, Player>, Map<Player, Player>>;
+}, z.core.$strip>;
+export type TacticsInput = z.infer<typeof TacticsInputSchema>;

package/dist/cjs/src/service/team/schemas/tactics.z.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TacticsInputSchema = void 0;
+const zod_1 = require("zod");
+const player_1 = require("../../player");
+const playerInstanceSchema = zod_1.z.custom((v) => v instanceof player_1.Player, {
+    message: 'INVALID_PLAYER_INSTANCE'
+});
+const LEFT_FRONT = 4;
+const MIDDLE_FRONT = 3;
+const RIGHT_FRONT = 2;
+const LEFT_BACK = 5;
+const MIDDLE_BACK = 6;
+const RIGHT_BACK = 1;
+const LIBERO_ZONE = 0;
+const lineupSchema = zod_1.z.object({
+    [LEFT_FRONT]: playerInstanceSchema,
+    [MIDDLE_FRONT]: playerInstanceSchema,
+    [RIGHT_FRONT]: playerInstanceSchema,
+    [LEFT_BACK]: playerInstanceSchema,
+    [MIDDLE_BACK]: playerInstanceSchema,
+    [RIGHT_BACK]: playerInstanceSchema,
+    [LIBERO_ZONE]: playerInstanceSchema.optional(),
+    bench: zod_1.z.array(playerInstanceSchema)
+}).superRefine((data, ctx) => {
+    const players = [
+        data[LEFT_FRONT],
+        data[MIDDLE_FRONT],
+        data[RIGHT_FRONT],
+        data[LEFT_BACK],
+        data[MIDDLE_BACK],
+        data[RIGHT_BACK],
+        ...(data[LIBERO_ZONE] != null ? [data[LIBERO_ZONE]] : []),
+        ...data.bench
+    ];
+    const ids = players.map(p => p.id);
+    const uniqueCount = new Set(ids).size;
+    if (uniqueCount !== ids.length) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'LINEUP_HAS_DUPLICATE_PLAYERS',
+            path: ['bench']
+        });
+    }
+});
+exports.TacticsInputSchema = zod_1.z.object({
+    lineup: lineupSchema,
+    substitutionTolerance: zod_1.z.number().int().min(1).max(50),
+    liberoReplacements: zod_1.z.array(playerInstanceSchema),
+    pinchServerSubs: zod_1.z.custom((v) => v instanceof Map &&
+        Array.from(v.entries()).every(([k, val]) => k instanceof player_1.Player && val instanceof player_1.Player), { message: 'INVALID_PINCH_SERVER_SUBS' })
+});

package/dist/cjs/src/service/team/schemas/team.z.d.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { Player } from '../../player';
+import { Country } from '../../country';
+export declare const TeamInputSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    rating: z.ZodNumber;
+    name: z.ZodString;
+    shortName: z.ZodString;
+    divisionId: z.ZodUUID;
+    roster: z.ZodArray<z.ZodCustom<Player, Player>>;
+    country: z.ZodCustom<Country, Country>;
+    tactics: z.ZodOptional<z.ZodObject<{
+        lineup: z.ZodObject<{
+            4: z.ZodCustom<Player, Player>;
+            3: z.ZodCustom<Player, Player>;
+            2: z.ZodCustom<Player, Player>;
+            5: z.ZodCustom<Player, Player>;
+            6: z.ZodCustom<Player, Player>;
+            1: z.ZodCustom<Player, Player>;
+            0: z.ZodOptional<z.ZodCustom<Player, Player>>;
+            bench: z.ZodArray<z.ZodCustom<Player, Player>>;
+        }, z.core.$strip>;
+        substitutionTolerance: z.ZodNumber;
+        liberoReplacements: z.ZodArray<z.ZodCustom<Player, Player>>;
+        pinchServerSubs: z.ZodCustom<Map<Player, Player>, Map<Player, Player>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type TeamInput = z.infer<typeof TeamInputSchema>;

package/dist/cjs/src/service/team/schemas/team.z.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TeamInputSchema = void 0;
+const zod_1 = require("zod");
+const player_1 = require("../../player");
+const country_1 = require("../../country");
+const tactics_z_1 = require("./tactics.z");
+const playerInstanceSchema = zod_1.z.custom((v) => v instanceof player_1.Player, {
+    message: 'INVALID_PLAYER_INSTANCE'
+});
+const countrySchema = zod_1.z.custom((v) => v instanceof country_1.Country, {
+    message: 'INVALID_COUNTRY_INSTANCE'
+});
+exports.TeamInputSchema = zod_1.z.object({
+    id: zod_1.z.uuid(),
+    rating: zod_1.z.number().finite(),
+    name: zod_1.z.string().trim().min(1),
+    shortName: zod_1.z.string().trim().min(1),
+    divisionId: zod_1.z.uuid(),
+    roster: zod_1.z.array(playerInstanceSchema),
+    country: countrySchema,
+    tactics: tactics_z_1.TacticsInputSchema.optional()
+}).superRefine((data, ctx) => {
+    const ids = data.roster.map(p => p.id);
+    if (new Set(ids).size !== ids.length) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'TEAM_ROSTER_HAS_DUPLICATE_PLAYERS',
+            path: ['roster']
+        });
+    }
+});

package/dist/cjs/src/service/team/tactics.d.ts

@@ -0,0 +1,27 @@
+import { CourtPosition } from '../match';
+import { Player } from '../player';
+export interface StartingLineup {
+    readonly [CourtPosition.LEFT_FRONT]: Player;
+    readonly [CourtPosition.MIDDLE_FRONT]: Player;
+    readonly [CourtPosition.RIGHT_FRONT]: Player;
+    readonly [CourtPosition.LEFT_BACK]: Player;
+    readonly [CourtPosition.MIDDLE_BACK]: Player;
+    readonly [CourtPosition.RIGHT_BACK]: Player;
+    readonly [CourtPosition.LIBERO_ZONE]?: Player;
+    readonly bench: Player[];
+}
+export interface TacticsOpts {
+    readonly lineup: StartingLineup;
+    readonly substitutionTolerance: number;
+    readonly liberoReplacements: Player[];
+    readonly pinchServerSubs: Map<Player, Player>;
+}
+export declare class Tactics {
+    readonly lineup: StartingLineup;
+    readonly substitutionTolerance: number;
+    readonly liberoReplacements: Player[];
+    readonly pinchServerSubs: Map<Player, Player>;
+    static create(input: unknown): Tactics;
+    private constructor();
+    findPlayerInLineup(id: string): CourtPosition | undefined;
+}

package/dist/cjs/src/service/team/tactics.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tactics = void 0;
+const match_1 = require("../match");
+const tactics_z_1 = require("./schemas/tactics.z");
+class Tactics {
+    static create(input) {
+        const result = tactics_z_1.TacticsInputSchema.safeParse(input);
+        if (!result.success) {
+            throw new Error(`INVALID_TACTICS: ${result.error.message}. RECEIVED=${(() => { try {
+                return JSON.stringify(input);
+            }
+            catch {
+                return String(input);
+            } })()}`);
+        }
+        return new Tactics(result.data);
+    }
+    constructor({ lineup, pinchServerSubs, liberoReplacements, substitutionTolerance = 1 }) {
+        this.lineup = lineup;
+        this.substitutionTolerance = substitutionTolerance;
+        this.pinchServerSubs = pinchServerSubs;
+        this.liberoReplacements = liberoReplacements;
+    }
+    findPlayerInLineup(id) {
+        if (this.lineup.bench.some(p => p.id === id))
+            return match_1.CourtPosition.NOT_IN_COURT;
+        if (this.lineup[match_1.CourtPosition.LEFT_FRONT].id === id)
+            return match_1.CourtPosition.LEFT_FRONT;
+        if (this.lineup[match_1.CourtPosition.MIDDLE_FRONT].id === id)
+            return match_1.CourtPosition.MIDDLE_FRONT;
+        if (this.lineup[match_1.CourtPosition.RIGHT_FRONT].id === id)
+            return match_1.CourtPosition.RIGHT_FRONT;
+        if (this.lineup[match_1.CourtPosition.LEFT_BACK].id === id)
+            return match_1.CourtPosition.LEFT_BACK;
+        if (this.lineup[match_1.CourtPosition.MIDDLE_BACK].id === id)
+            return match_1.CourtPosition.MIDDLE_BACK;
+        if (this.lineup[match_1.CourtPosition.RIGHT_BACK].id === id)
+            return match_1.CourtPosition.RIGHT_BACK;
+        if (this.lineup[match_1.CourtPosition.LIBERO_ZONE]?.id === id)
+            return match_1.CourtPosition.LIBERO_ZONE;
+    }
+}
+exports.Tactics = Tactics;

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

@@ -0,0 +1,15 @@
+import { Player, RarityEnum, Role } from '../player';
+import { Team } from './team';
+import { Country } from '../country';
+import { Tactics } from './tactics';
+export declare class TeamGenerator {
+    static readonly TEAM_PER_DIVISION = 16;
+    static readonly RARITIES: RarityEnum[];
+    static readonly ROLES: Role[];
+    private static getFormation;
+    private static comparePlayers;
+    static createRoster(country: Country): Player[];
+    static createTeams(divisionId: string, country: Country): Team[];
+    static createTactics(roster: Player[]): Tactics;
+    private static createLineup;
+}

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

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TeamGenerator = void 0;
+const uuid_1 = require("uuid");
+const player_1 = require("../player");
+const utils_1 = require("../utils");
+const team_1 = require("./team");
+const tactics_1 = require("./tactics");
+const formation_1 = require("./formation");
+const match_1 = require("../match");
+const logger_1 = __importDefault(require("../../logger"));
+const buildBlock = (rarity, count) => Array.from({ length: count }, () => rarity);
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+class TeamGenerator {
+    static getFormation() {
+        const n = Math.floor(Math.random() * 3);
+        switch (n) {
+            case 0:
+                return formation_1.Formation['4-2'];
+            case 1:
+                return formation_1.Formation['5-1'];
+            case 2:
+                return formation_1.Formation['6-2'];
+            default:
+                throw new Error('INVALID NUMBER');
+        }
+    }
+    static comparePlayers(roles) {
+        return (p1, p2) => roles.reduce((x, role) => {
+            const p2Score = (0, player_1.calculateRoleScore)(p2.stats, role);
+            const p1Score = (0, player_1.calculateRoleScore)(p1.stats, role);
+            return x + p2Score - p1Score;
+        }, 0);
+    }
+    static createRoster(country) {
+        return TeamGenerator.RARITIES.map((rarity, i) => player_1.PlayerGenerator.generatePlayer(country, rarity, this.ROLES[i % TeamGenerator.ROLES.length]));
+    }
+    static createTeams(divisionId, country) {
+        const names = (0, utils_1.generateGenericTeamNames)(country.locales, TeamGenerator.TEAM_PER_DIVISION);
+        logger_1.default.info(`Creating teams for division: ${divisionId}`);
+        return names.map((name) => {
+            logger_1.default.info(`Creating players for team: ${name}`);
+            const roster = TeamGenerator.createRoster(country);
+            const tactics = TeamGenerator.createTactics(roster);
+            const shortName = name.replace(/\s+/g, '')
+                .slice(0, 3)
+                .toUpperCase();
+            return team_1.Team.create({
+                id: (0, uuid_1.v4)(),
+                divisionId,
+                name,
+                shortName,
+                roster,
+                country,
+                tactics,
+                rating: 100
+            });
+        });
+    }
+    static createTactics(roster) {
+        const lineup = TeamGenerator.createLineup(roster, TeamGenerator.getFormation());
+        return tactics_1.Tactics.create({
+            lineup,
+            liberoReplacements: [lineup[3], lineup[6]],
+            pinchServerSubs: new Map(),
+            substitutionTolerance: Math.round((0, utils_1.randomNumber)(1, 50))
+        });
+    }
+    static createLineup(players, formation) {
+        if (players.length < 6)
+            throw new Error('NOT_ENOUGH_PLAYERS_FOR_TEAM_1');
+        const out = {};
+        let courtPlayer;
+        const libero = players.filter((player) => player.roles.includes(player_1.RoleEnum.LIBERO))
+            .sort(TeamGenerator.comparePlayers([player_1.RoleEnum.LIBERO]))
+            .shift();
+        if (libero == null)
+            throw new Error('UNDEFINED_LIBERO');
+        const filtered = players.filter(player => player.id !== libero.id);
+        for (let i = 1; i < 7; i++) {
+            courtPlayer = filtered.sort(TeamGenerator.comparePlayers(formation.initialRotation[i]))
+                .shift();
+            if (courtPlayer == null)
+                throw new Error('NOT_ENOUGH_PLAYERS_FOR_TEAM_2');
+            out[i] = courtPlayer;
+        }
+        // Can only have 12 players in the team.
+        out.bench = filtered.sort(player_1.Player.compareStats)
+            .slice(0, 5);
+        out[match_1.CourtPosition.LIBERO_ZONE] = libero;
+        return out;
+    }
+}
+exports.TeamGenerator = TeamGenerator;
+TeamGenerator.TEAM_PER_DIVISION = 16;
+TeamGenerator.RARITIES = [
+    ...buildBlock(player_1.RarityEnum.COMMON, 7),
+    ...buildBlock(player_1.RarityEnum.RARE, 5),
+    ...buildBlock(player_1.RarityEnum.LEGENDARY, 2)
+];
+TeamGenerator.ROLES = [player_1.RoleEnum.LIBERO, player_1.RoleEnum.MIDDLE_BLOCKER, player_1.RoleEnum.OPPOSITE_HITTER, player_1.RoleEnum.OUTSIDE_HITTER, player_1.RoleEnum.SETTER];

package/dist/cjs/src/service/team/team.d.ts

@@ -0,0 +1,20 @@
+import { Player } from '../player';
+import { Country } from '../country';
+import { Tactics } from './tactics';
+export declare class Team {
+    readonly id: string;
+    readonly roster: Player[];
+    readonly name: string;
+    readonly shortName: string;
+    readonly divisionId: string;
+    readonly tactics?: Tactics;
+    readonly country: Country;
+    private _rating;
+    static create(input: unknown): Team;
+    private constructor();
+    get rating(): number;
+    set rating(value: number);
+    isPlayerInRoster(player: Player): boolean;
+    toString(): string;
+    updateRating(rankingPoints: number): void;
+}

package/dist/cjs/src/service/team/team.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Team = void 0;
+const tactics_1 = require("./tactics");
+const team_z_1 = require("./schemas/team.z");
+class Team {
+    static create(input) {
+        const result = team_z_1.TeamInputSchema.safeParse(input);
+        if (!result.success) {
+            throw new Error(`INVALID_TEAM: ${result.error.message}. RECEIVED=${(() => { try {
+                return JSON.stringify(input);
+            }
+            catch {
+                return String(input);
+            } })()}`);
+        }
+        return new Team({
+            ...result.data,
+            tactics: result.data.tactics != null ? tactics_1.Tactics.create(result.data.tactics) : undefined
+        });
+    }
+    constructor({ id, rating, name, shortName, divisionId, country, roster, tactics }) {
+        this.id = id;
+        this._rating = rating;
+        this.roster = roster;
+        this.tactics = tactics;
+        this.name = name;
+        this.shortName = shortName;
+        this.divisionId = divisionId;
+        this.country = country;
+    }
+    get rating() {
+        return this._rating;
+    }
+    set rating(value) {
+        this._rating = value;
+    }
+    isPlayerInRoster(player) {
+        return this.roster.some(p => p.id === player.id);
+    }
+    toString() {
+        if (this.country == null) {
+            throw new Error('UNKNOWN_COUNTRY');
+        }
+        return `${this.name} [${this.shortName}] (${this.country?.name}) ELO=${this._rating}`;
+    }
+    updateRating(rankingPoints) {
+        this._rating += rankingPoints;
+    }
+}
+exports.Team = Team;

package/dist/cjs/src/service/test-helpers.d.ts

@@ -0,0 +1,38 @@
+import { Country } from './country';
+import { Player } from './player';
+import { Team } from './team';
+import { Match } from './match';
+import { MatchSet } from './match/match-set';
+export declare function makeCountry(): Country;
+export declare function makePlayer(country: Country, statValue?: number): Player;
+export declare function makeTeam(opts?: {
+    rating?: number;
+}): Team;
+/** Creates a finished MatchSet with no rallies (schema allows empty rallies at non-zero score). */
+export declare function makeFinishedSet(homeScore: number, awayScore: number, order?: number): MatchSet;
+/**
+ * Creates a COMPLETE Match where the home team wins 3-0.
+ * Sets: 25-10, 25-12, 25-8.
+ */
+export declare function makeMatch30(homeTeam: Team, awayTeam: Team): Match;
+/**
+ * Creates a COMPLETE Match where the home team wins 3-1.
+ * Sets (home wins 3, away wins 1): 25-20, 20-25, 25-18, 25-15.
+ */
+export declare function makeMatch31(homeTeam: Team, awayTeam: Team): Match;
+/**
+ * Creates a PENDING Match (no sets, no score).
+ */
+export declare function makePendingMatch(homeTeam: Team, awayTeam: Team): Match;
+/**
+ * Computes all derived Standing fields from raw win/loss counts so that
+ * Standing.create() passes its superRefine validation.
+ */
+export declare function standingInput(teamId: string, opts?: {
+    won30?: number;
+    won31?: number;
+    won32?: number;
+    lost03?: number;
+    lost13?: number;
+    lost23?: number;
+}): object;

package/dist/cjs/src/service/test-helpers.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeCountry = makeCountry;
+exports.makePlayer = makePlayer;
+exports.makeTeam = makeTeam;
+exports.makeFinishedSet = makeFinishedSet;
+exports.makeMatch30 = makeMatch30;
+exports.makeMatch31 = makeMatch31;
+exports.makePendingMatch = makePendingMatch;
+exports.standingInput = standingInput;
+/**
+ * Minimal object factories for unit tests.
+ * NOT exported from any barrel — import directly from this file.
+ */
+const uuid_1 = require("uuid");
+const country_1 = require("./country");
+const player_1 = require("./player");
+const team_1 = require("./team");
+const match_1 = require("./match");
+const match_set_1 = require("./match/match-set");
+const common_1 = require("../data/common");
+const rarity_1 = require("./player/rarity");
+const role_1 = require("./player/role");
+const decline_1 = require("./player/decline");
+const performance_stats_keys_1 = require("./player/performance-stats-keys");
+// ─── Country ─────────────────────────────────────────────────────────────────
+function makeCountry() {
+    return country_1.Country.create({
+        id: (0, uuid_1.v4)(),
+        name: 'Test Country',
+        alpha2: 'TC',
+        alpha3: 'TCN',
+        code: 'TCN',
+        iso31662: 'TC-TEST'
+    });
+}
+// ─── Player ───────────────────────────────────────────────────────────────────
+function makePlayer(country, statValue = 50) {
+    const stats = Object.fromEntries(performance_stats_keys_1.performanceStatKeys.map((k) => [k, statValue]));
+    return player_1.Player.create({
+        id: (0, uuid_1.v4)(),
+        name: { first: 'Test', last: 'Player' },
+        country,
+        stats,
+        roles: [role_1.RoleEnum.OUTSIDE_HITTER],
+        traits: [],
+        rarity: rarity_1.RarityEnum.COMMON,
+        age: 20,
+        declineProfile: decline_1.DeclineProfileEnum.STANDARD
+    });
+}
+// ─── Team ─────────────────────────────────────────────────────────────────────
+function makeTeam(opts = {}) {
+    const country = makeCountry();
+    const player = makePlayer(country);
+    return team_1.Team.create({
+        id: (0, uuid_1.v4)(),
+        rating: opts.rating ?? 100,
+        name: 'Test Team',
+        shortName: 'TST',
+        divisionId: (0, uuid_1.v4)(),
+        roster: [player],
+        country
+    });
+}
+// ─── MatchSet ────────────────────────────────────────────────────────────────
+/** Creates a finished MatchSet with no rallies (schema allows empty rallies at non-zero score). */
+function makeFinishedSet(homeScore, awayScore, order = 0) {
+    return match_set_1.MatchSet.create({
+        id: (0, uuid_1.v4)(),
+        order,
+        isTieBreak: false,
+        homePlayerPosition: [],
+        awayPlayerPosition: [],
+        homeScore,
+        awayScore,
+        boxScores: [],
+        rallies: []
+    });
+}
+// ─── Match ───────────────────────────────────────────────────────────────────
+/**
+ * Creates a COMPLETE Match where the home team wins 3-0.
+ * Sets: 25-10, 25-12, 25-8.
+ */
+function makeMatch30(homeTeam, awayTeam) {
+    const sets = [
+        makeFinishedSet(25, 10, 0),
+        makeFinishedSet(25, 12, 1),
+        makeFinishedSet(25, 8, 2)
+    ];
+    return match_1.Match.create({
+        id: (0, uuid_1.v4)(),
+        homeTeam,
+        awayTeam,
+        scheduledDate: new Date(),
+        status: common_1.StatusEnum.COMPLETE,
+        homeScore: 3,
+        awayScore: 0,
+        sets,
+        winner: homeTeam
+    });
+}
+/**
+ * Creates a COMPLETE Match where the home team wins 3-1.
+ * Sets (home wins 3, away wins 1): 25-20, 20-25, 25-18, 25-15.
+ */
+function makeMatch31(homeTeam, awayTeam) {
+    const sets = [
+        makeFinishedSet(25, 20, 0),
+        makeFinishedSet(20, 25, 1),
+        makeFinishedSet(25, 18, 2),
+        makeFinishedSet(25, 15, 3)
+    ];
+    return match_1.Match.create({
+        id: (0, uuid_1.v4)(),
+        homeTeam,
+        awayTeam,
+        scheduledDate: new Date(),
+        status: common_1.StatusEnum.COMPLETE,
+        homeScore: 3,
+        awayScore: 1,
+        sets,
+        winner: homeTeam
+    });
+}
+/**
+ * Creates a PENDING Match (no sets, no score).
+ */
+function makePendingMatch(homeTeam, awayTeam) {
+    return match_1.Match.create({
+        id: (0, uuid_1.v4)(),
+        homeTeam,
+        awayTeam,
+        scheduledDate: new Date(),
+        status: common_1.StatusEnum.PENDING
+    });
+}
+// ─── Standing input ───────────────────────────────────────────────────────────
+/**
+ * Computes all derived Standing fields from raw win/loss counts so that
+ * Standing.create() passes its superRefine validation.
+ */
+function standingInput(teamId, opts = {}) {
+    const w30 = opts.won30 ?? 0;
+    const w31 = opts.won31 ?? 0;
+    const w32 = opts.won32 ?? 0;
+    const l03 = opts.lost03 ?? 0;
+    const l13 = opts.lost13 ?? 0;
+    const l23 = opts.lost23 ?? 0;
+    return {
+        teamId,
+        won30: w30,
+        won31: w31,
+        won32: w32,
+        lost03: l03,
+        lost13: l13,
+        lost23: l23,
+        points: (w30 + w31) * 3 + w32 * 2 + l23,
+        setsWon: (w32 + w31 + w30) * 3 + l23 * 2 + l13,
+        setsLost: (l03 + l13 + l23) * 3 + w32 * 2 + w31,
+        matchesWon: w30 + w31 + w32,
+        matchesLost: l03 + l13 + l23,
+        totalMatches: w30 + w31 + w32 + l03 + l13 + l23
+    };
+}

package/dist/cjs/src/service/utils/faker-generators.d.ts

@@ -0,0 +1,25 @@
+export declare function getFakerInstance(locales: string[]): FakerLike;
+interface FakerLike {
+    location: {
+        city: () => string;
+        state?: () => string;
+        county?: () => string;
+    };
+    person: {
+        firstName: () => string;
+        lastName: () => string;
+    };
+    word: {
+        adjective: () => string;
+        noun: () => string;
+    };
+    datatype: {
+        boolean: () => boolean;
+    };
+}
+export declare function generateGenericTeamNames(locales: string[], amount: number): string[];
+export declare function generatePlayerName(locales: string[], amount: number): Array<{
+    first: string;
+    last: string;
+}>;
+export {};