volleyballsimtypes 0.0.359 → 0.0.361

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

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Player = exports.Name = exports.Stat = void 0;
+const performance_stats_1 = require("./performance-stats");
+const stats_1 = require("./stats");
+const role_1 = require("./role");
+const player_z_1 = require("./schemas/player.z");
+class Stat {
+    constructor({ name, value }) {
+        this.name = name;
+        this.value = value;
+    }
+    toString() {
+        return `${this.name}: ${this.value}`;
+    }
+}
+exports.Stat = Stat;
+class Name {
+    static create(input) {
+        const result = player_z_1.NameInputSchema.safeParse(input);
+        if (!result.success) {
+            throw new Error(`INVALID_NAME: ${result.error.message}. RECEIVED=${(() => { try {
+                return JSON.stringify(input);
+            }
+            catch {
+                return String(input);
+            } })()}`);
+        }
+        return new Name(result.data);
+    }
+    constructor({ first, last }) {
+        this.first = first;
+        this.last = last;
+    }
+    toString() {
+        return `${this.first} ${this.last}`;
+    }
+}
+exports.Name = Name;
+class Player {
+    static create(input) {
+        const result = player_z_1.PlayerInputSchema.safeParse(input);
+        if (!result.success) {
+            throw new Error(`INVALID_PLAYER: ${result.error.message}. RECEIVED=${(() => { try {
+                return JSON.stringify(input);
+            }
+            catch {
+                return String(input);
+            } })()}`);
+        }
+        return new Player({
+            ...result.data,
+            name: Name.create(result.data.name),
+            stats: performance_stats_1.PerformanceStats.create(result.data.stats)
+        });
+    }
+    constructor({ id, name, country, stats, roles, traits, rarity, age, declineProfile, boxScores, boxScoreTotals }) {
+        this.id = id;
+        this.name = name;
+        this.country = country;
+        this.stats = stats;
+        this.roles = roles;
+        this.traits = traits;
+        this.rarity = rarity;
+        this.age = age;
+        this.declineProfile = declineProfile;
+        this.boxScores = boxScores;
+        this.boxScoreTotals = boxScoreTotals;
+        this.generalStats = Object.values(stats_1.StatsEnum).map((stat) => ({
+            name: stat,
+            value: (0, stats_1.calculateStatScore)(stats, stat)
+        }));
+    }
+    // Used as a base sorting function for players
+    static sortPlayers(roles) {
+        return (p1, p2) => roles.reduce((x, role) => {
+            const p2Score = (0, role_1.calculateRoleScore)(p2.stats, role);
+            const p1Score = (0, role_1.calculateRoleScore)(p1.stats, role);
+            return x + p2Score - p1Score;
+        }, 0);
+    }
+    static compareStats(p1, p2) {
+        const compareFn = (acc, current) => {
+            let x = current.value;
+            switch (current.name) {
+                case stats_1.StatsEnum.ATTACK:
+                    x *= 0.19;
+                    break;
+                case stats_1.StatsEnum.SET:
+                    x *= 0.19;
+                    break;
+                case stats_1.StatsEnum.RECEIVE:
+                    x *= 0.19;
+                    break;
+                case stats_1.StatsEnum.BLOCK:
+                    x *= 0.19;
+                    break;
+                case stats_1.StatsEnum.SERVE:
+                    x *= 0.19;
+                    break;
+                case stats_1.StatsEnum.STAMINA:
+                    x *= 0.05;
+                    break;
+                default:
+                    x *= 0;
+            }
+            return acc + x;
+        };
+        const s1 = p1.generalStats.reduce(compareFn, 0);
+        const s2 = p2.generalStats.reduce(compareFn, 0);
+        return s2 - s1;
+    }
+    toString() {
+        return JSON.stringify({
+            id: this.id,
+            name: this.name.toString(),
+            country: this.country.toString(),
+            stats: this.stats.toString(),
+            rarity: this.rarity,
+            roles: `[${this.roles.map(r => r.toString()).join(',')}]`,
+            traits: `[${this.traits.map(t => t.toString()).join(',')}]`,
+            generalStats: `[${this.generalStats.map(r => r.toString()).join(',')}]`
+        });
+    }
+}
+exports.Player = Player;

package/dist/cjs/src/service/player/rarity.d.ts

@@ -0,0 +1,15 @@
+export declare enum RarityEnum {
+    COMMON = "COMMON",
+    RARE = "RARE",
+    LEGENDARY = "LEGENDARY",
+    MYTHIC = "MYTHIC",
+    SPECIAL = "SPECIAL"
+}
+export type Rarity = RarityEnum.COMMON | RarityEnum.RARE | RarityEnum.LEGENDARY | RarityEnum.MYTHIC | RarityEnum.SPECIAL;
+export declare const RarityRanges: {
+    COMMON: number[];
+    RARE: number[];
+    LEGENDARY: number[];
+    MYTHIC: number[];
+    SPECIAL: number[];
+};

package/dist/cjs/src/service/player/rarity.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RarityRanges = exports.RarityEnum = void 0;
+var RarityEnum;
+(function (RarityEnum) {
+    RarityEnum["COMMON"] = "COMMON";
+    RarityEnum["RARE"] = "RARE";
+    RarityEnum["LEGENDARY"] = "LEGENDARY";
+    RarityEnum["MYTHIC"] = "MYTHIC";
+    RarityEnum["SPECIAL"] = "SPECIAL";
+})(RarityEnum || (exports.RarityEnum = RarityEnum = {}));
+exports.RarityRanges = {
+    [RarityEnum.COMMON]: [1, 59],
+    [RarityEnum.RARE]: [51, 69],
+    [RarityEnum.LEGENDARY]: [71, 79],
+    [RarityEnum.MYTHIC]: [80, 89],
+    [RarityEnum.SPECIAL]: [90, 99]
+};

package/dist/cjs/src/service/player/role.d.ts

@@ -0,0 +1,28 @@
+import { PerformanceStats, PerformanceStatsParams } from './performance-stats';
+import { Rarity } from './rarity';
+export declare enum RoleEnum {
+    SETTER = "SETTER",
+    LIBERO = "LIBERO",
+    OUTSIDE_HITTER = "OUTSIDE_HITTER",
+    OPPOSITE_HITTER = "OPPOSITE_HITTER",
+    MIDDLE_BLOCKER = "MIDDLE_BLOCKER"
+}
+export type Role = RoleEnum.SETTER | RoleEnum.LIBERO | RoleEnum.MIDDLE_BLOCKER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER;
+export type RoleEventAction = 'reception' | 'set' | 'spike' | 'block';
+export interface RolesFormula {
+    role: Role;
+    weight: PerformanceStatsParams;
+}
+export declare function calculateRoleScore(stats: PerformanceStats, role: Role): number;
+export declare function assignRoles(stats: PerformanceStats, rarity: Rarity): Role[];
+/**
+ * Returns the role-based multiplier for a player performing a given action.
+ * When the player holds multiple roles, the least-penalising role wins.
+ * Defaults to the harshest penalty for that action if roles is empty.
+ */
+export declare function getRoleEventPenalty(roles: Role[], action: Exclude<RoleEventAction, 'block'>): number;
+/**
+ * Returns the role-based multiplier for a block sequence.
+ * If any blocker holds MIDDLE_BLOCKER, the whole block has no penalty.
+ */
+export declare function getBlockRolePenalty(blockerRoles: Role[][]): number;

package/dist/cjs/src/service/player/role.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoleEnum = void 0;
+exports.calculateRoleScore = calculateRoleScore;
+exports.assignRoles = assignRoles;
+exports.getRoleEventPenalty = getRoleEventPenalty;
+exports.getBlockRolePenalty = getBlockRolePenalty;
+const rarity_1 = require("./rarity");
+const roles_json_1 = __importDefault(require("../../stat-config/roles.json"));
+var RoleEnum;
+(function (RoleEnum) {
+    RoleEnum["SETTER"] = "SETTER";
+    RoleEnum["LIBERO"] = "LIBERO";
+    RoleEnum["OUTSIDE_HITTER"] = "OUTSIDE_HITTER";
+    RoleEnum["OPPOSITE_HITTER"] = "OPPOSITE_HITTER";
+    RoleEnum["MIDDLE_BLOCKER"] = "MIDDLE_BLOCKER";
+})(RoleEnum || (exports.RoleEnum = RoleEnum = {}));
+const rolesFormula = roles_json_1.default;
+// ─── Role score ───────────────────────────────────────────────────────────────
+function calculateRoleScore(stats, role) {
+    const weights = rolesFormula.find(r => r.role === role);
+    if (weights == null)
+        throw new Error('COULD_NOT_FIND_ROLE_WEIGHT');
+    const score = Object.keys(weights.weight)
+        .reduce((score, key) => {
+        const stat = stats[key];
+        const weight = weights.weight[key];
+        return score + (stat * weight);
+    }, 0);
+    return Math.round(score);
+}
+// ─── Role assignment ──────────────────────────────────────────────────────────
+function getRoleCountRange(rarity) {
+    switch (rarity) {
+        case rarity_1.RarityEnum.COMMON: return [1, 2];
+        case rarity_1.RarityEnum.RARE: return [1, 3];
+        case rarity_1.RarityEnum.LEGENDARY: return [1, 4];
+        case rarity_1.RarityEnum.MYTHIC: return [2, 4];
+        case rarity_1.RarityEnum.SPECIAL: return [3, 5];
+        default: return [1, 2];
+    }
+}
+function assignRoles(stats, rarity) {
+    const scores = Object.values(RoleEnum)
+        .map((role) => ({
+        role,
+        score: calculateRoleScore(stats, role)
+    }))
+        .sort((x, y) => y.score - x.score);
+    const [min, max] = getRoleCountRange(rarity);
+    const count = min + Math.floor(Math.random() * (max - min + 1));
+    return scores.slice(0, count).map(s => s.role);
+}
+// ─── Role event penalties ─────────────────────────────────────────────────────
+const ROLE_PENALTY_TABLE = {
+    [RoleEnum.LIBERO]: { reception: 1.00, set: 0.98, spike: 0.90 },
+    [RoleEnum.SETTER]: { reception: 0.92, set: 1.00, spike: 0.98 },
+    [RoleEnum.OUTSIDE_HITTER]: { reception: 0.95, set: 0.95, spike: 1.00 },
+    [RoleEnum.OPPOSITE_HITTER]: { reception: 0.92, set: 0.95, spike: 1.00 },
+    [RoleEnum.MIDDLE_BLOCKER]: { reception: 0.85, set: 0.90, spike: 0.95 }
+};
+/**
+ * Returns the role-based multiplier for a player performing a given action.
+ * When the player holds multiple roles, the least-penalising role wins.
+ * Defaults to the harshest penalty for that action if roles is empty.
+ */
+function getRoleEventPenalty(roles, action) {
+    if (roles.length === 0) {
+        // fallback: use MIDDLE_BLOCKER penalties (most penalised for non-block actions)
+        return ROLE_PENALTY_TABLE[RoleEnum.MIDDLE_BLOCKER][action];
+    }
+    return Math.max(...roles.map(role => ROLE_PENALTY_TABLE[role][action]));
+}
+/**
+ * Returns the role-based multiplier for a block sequence.
+ * If any blocker holds MIDDLE_BLOCKER, the whole block has no penalty.
+ */
+function getBlockRolePenalty(blockerRoles) {
+    const anyMB = blockerRoles.some(roles => roles.includes(RoleEnum.MIDDLE_BLOCKER));
+    return anyMB ? 1.00 : 0.90;
+}

package/dist/cjs/src/service/player/role.test.d.ts

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

package/dist/cjs/src/service/player/role.test.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const rarity_1 = require("./rarity");
+const role_1 = require("./role");
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+/** Builds a flat PerformanceStats where every stat = value */
+function flatStats(value) {
+    return {
+        setting: value,
+        serve: value,
+        spike: value,
+        quick: value,
+        power: value,
+        awareness: value,
+        attack: value,
+        backAttack: value,
+        reception: value,
+        overhand: value,
+        bump: value,
+        block: value,
+        read: value,
+        commit: value,
+        focus: value,
+        defense: value,
+        stamina: value,
+        reflex: value
+    };
+}
+/** Builds PerformanceStats biased toward setting (SETTER archetype) */
+function setterStats() {
+    return { ...flatStats(20), setting: 90, overhand: 80, awareness: 70, attack: 65 };
+}
+// ─── assignRoles ──────────────────────────────────────────────────────────────
+(0, globals_1.describe)('assignRoles()', () => {
+    const ITERATIONS = 2000;
+    globals_1.it.each([
+        [rarity_1.RarityEnum.COMMON, 1, 2],
+        [rarity_1.RarityEnum.RARE, 1, 3],
+        [rarity_1.RarityEnum.LEGENDARY, 1, 4],
+        [rarity_1.RarityEnum.MYTHIC, 2, 4],
+        [rarity_1.RarityEnum.SPECIAL, 3, 5]
+    ])('%s: role count always within [%i, %i]', (rarity, min, max) => {
+        const stats = flatStats(50);
+        for (let i = 0; i < ITERATIONS; i++) {
+            const roles = (0, role_1.assignRoles)(stats, rarity);
+            (0, globals_1.expect)(roles.length).toBeGreaterThanOrEqual(min);
+            (0, globals_1.expect)(roles.length).toBeLessThanOrEqual(max);
+        }
+    });
+    (0, globals_1.it)('primary role is always the highest-scoring role', () => {
+        const stats = setterStats();
+        for (let i = 0; i < 200; i++) {
+            const roles = (0, role_1.assignRoles)(stats, rarity_1.RarityEnum.LEGENDARY);
+            (0, globals_1.expect)(roles[0]).toBe(role_1.RoleEnum.SETTER);
+        }
+    });
+    (0, globals_1.it)('MYTHIC player always gets at least 2 roles', () => {
+        const stats = flatStats(50);
+        for (let i = 0; i < ITERATIONS; i++) {
+            const roles = (0, role_1.assignRoles)(stats, rarity_1.RarityEnum.MYTHIC);
+            (0, globals_1.expect)(roles.length).toBeGreaterThanOrEqual(2);
+        }
+    });
+    (0, globals_1.it)('SPECIAL player always gets at least 3 roles', () => {
+        const stats = flatStats(50);
+        for (let i = 0; i < ITERATIONS; i++) {
+            const roles = (0, role_1.assignRoles)(stats, rarity_1.RarityEnum.SPECIAL);
+            (0, globals_1.expect)(roles.length).toBeGreaterThanOrEqual(3);
+        }
+    });
+    (0, globals_1.it)('roles are unique (no duplicates)', () => {
+        const stats = flatStats(50);
+        for (let i = 0; i < 500; i++) {
+            const roles = (0, role_1.assignRoles)(stats, rarity_1.RarityEnum.SPECIAL);
+            (0, globals_1.expect)(new Set(roles).size).toBe(roles.length);
+        }
+    });
+    (0, globals_1.it)('each role appears at most once', () => {
+        const allRoles = Object.values(role_1.RoleEnum);
+        for (let i = 0; i < 500; i++) {
+            const roles = (0, role_1.assignRoles)(flatStats(50), rarity_1.RarityEnum.SPECIAL);
+            allRoles.forEach(role => {
+                (0, globals_1.expect)(roles.filter(r => r === role).length).toBeLessThanOrEqual(1);
+            });
+        }
+    });
+});
+// ─── getRoleEventPenalty ──────────────────────────────────────────────────────
+(0, globals_1.describe)('getRoleEventPenalty()', () => {
+    // ── reception ──
+    (0, globals_1.describe)('reception', () => {
+        (0, globals_1.it)('LIBERO has no penalty (1.00)', () => {
+            (0, globals_1.expect)((0, role_1.getRoleEventPenalty)([role_1.RoleEnum.LIBERO], 'reception')).toBeCloseTo(1.00);
+        });
+        (0, globals_1.it)('OUTSIDE_HITTER has 5% penalty (0.95)', () => {
+            (0, globals_1.expect)((0, role_1.getRoleEventPenalty)([role_1.RoleEnum.OUTSIDE_HITTER], 'reception')).toBeCloseTo(0.95);
+        });
+        (0, globals_1.it)('SETTER has 8% penalty (0.92)', () => {
+            (0, globals_1.expect)((0, role_1.getRoleEventPenalty)([role_1.RoleEnum.SETTER], 'reception')).toBeCloseTo(0.92);
+        });
+        (0, globals_1.it)('OPPOSITE_HITTER has 8% penalty (0.92)', () => {
+            (0, globals_1.expect)((0, role_1.getRoleEventPenalty)([role_1.RoleEnum.OPPOSITE_HITTER], 'reception')).toBeCloseTo(0.92);
+        });
+        (0, globals_1.it)('MIDDLE_BLOCKER has full 15% penalty (0.85)', () => {
+            (0, globals_1.expect)((0, role_1.getRoleEventPenalty)([role_1.RoleEnum.MIDDLE_BLOCKER], 'reception')).toBeCloseTo(0.85);
+        });
+    });
+    // ── set ──
+    (0, globals_1.describe)('set', () => {
+        (0, globals_1.it)('SETTER has no penalty (1.00)', () => {
+            (0, globals_1.expect)((0, role_1.getRoleEventPenalty)([role_1.RoleEnum.SETTER], 'set')).toBeCloseTo(1.00);
+        });
+        (0, globals_1.it)('LIBERO has 2% penalty (0.98)', () => {
+            (0, globals_1.expect)((0, role_1.getRoleEventPenalty)([role_1.RoleEnum.LIBERO], 'set')).toBeCloseTo(0.98);
+        });
+        (0, globals_1.it)('OUTSIDE_HITTER has 5% penalty (0.95)', () => {
+            (0, globals_1.expect)((0, role_1.getRoleEventPenalty)([role_1.RoleEnum.OUTSIDE_HITTER], 'set')).toBeCloseTo(0.95);
+        });
+        (0, globals_1.it)('OPPOSITE_HITTER has 5% penalty (0.95)', () => {
+            (0, globals_1.expect)((0, role_1.getRoleEventPenalty)([role_1.RoleEnum.OPPOSITE_HITTER], 'set')).toBeCloseTo(0.95);
+        });
+        (0, globals_1.it)('MIDDLE_BLOCKER has full 10% penalty (0.90)', () => {
+            (0, globals_1.expect)((0, role_1.getRoleEventPenalty)([role_1.RoleEnum.MIDDLE_BLOCKER], 'set')).toBeCloseTo(0.90);
+        });
+    });
+    // ── spike ──
+    (0, globals_1.describe)('spike', () => {
+        (0, globals_1.it)('OUTSIDE_HITTER has no penalty (1.00)', () => {
+            (0, globals_1.expect)((0, role_1.getRoleEventPenalty)([role_1.RoleEnum.OUTSIDE_HITTER], 'spike')).toBeCloseTo(1.00);
+        });
+        (0, globals_1.it)('OPPOSITE_HITTER has no penalty (1.00)', () => {
+            (0, globals_1.expect)((0, role_1.getRoleEventPenalty)([role_1.RoleEnum.OPPOSITE_HITTER], 'spike')).toBeCloseTo(1.00);
+        });
+        (0, globals_1.it)('SETTER has 2% penalty (0.98)', () => {
+            (0, globals_1.expect)((0, role_1.getRoleEventPenalty)([role_1.RoleEnum.SETTER], 'spike')).toBeCloseTo(0.98);
+        });
+        (0, globals_1.it)('MIDDLE_BLOCKER has 5% penalty (0.95)', () => {
+            (0, globals_1.expect)((0, role_1.getRoleEventPenalty)([role_1.RoleEnum.MIDDLE_BLOCKER], 'spike')).toBeCloseTo(0.95);
+        });
+        (0, globals_1.it)('LIBERO has full 10% penalty (0.90)', () => {
+            (0, globals_1.expect)((0, role_1.getRoleEventPenalty)([role_1.RoleEnum.LIBERO], 'spike')).toBeCloseTo(0.90);
+        });
+    });
+    // ── multi-role: best wins ──
+    (0, globals_1.describe)('multi-role selects lowest penalty', () => {
+        (0, globals_1.it)('[MIDDLE_BLOCKER, LIBERO] receiving → LIBERO wins (1.00)', () => {
+            (0, globals_1.expect)((0, role_1.getRoleEventPenalty)([role_1.RoleEnum.MIDDLE_BLOCKER, role_1.RoleEnum.LIBERO], 'reception')).toBeCloseTo(1.00);
+        });
+        (0, globals_1.it)('[MIDDLE_BLOCKER, SETTER] setting → SETTER wins (1.00)', () => {
+            (0, globals_1.expect)((0, role_1.getRoleEventPenalty)([role_1.RoleEnum.MIDDLE_BLOCKER, role_1.RoleEnum.SETTER], 'set')).toBeCloseTo(1.00);
+        });
+        (0, globals_1.it)('[LIBERO, OUTSIDE_HITTER] spiking → OH wins (1.00)', () => {
+            (0, globals_1.expect)((0, role_1.getRoleEventPenalty)([role_1.RoleEnum.LIBERO, role_1.RoleEnum.OUTSIDE_HITTER], 'spike')).toBeCloseTo(1.00);
+        });
+        (0, globals_1.it)('[SETTER, OUTSIDE_HITTER] receiving → OH wins (0.95 over 0.92)', () => {
+            (0, globals_1.expect)((0, role_1.getRoleEventPenalty)([role_1.RoleEnum.SETTER, role_1.RoleEnum.OUTSIDE_HITTER], 'reception')).toBeCloseTo(0.95);
+        });
+    });
+    // ── empty roles fallback ──
+    (0, globals_1.it)('empty roles array falls back to maximum penalty', () => {
+        (0, globals_1.expect)((0, role_1.getRoleEventPenalty)([], 'reception')).toBeCloseTo(0.85);
+        (0, globals_1.expect)((0, role_1.getRoleEventPenalty)([], 'set')).toBeCloseTo(0.90);
+        (0, globals_1.expect)((0, role_1.getRoleEventPenalty)([], 'spike')).toBeCloseTo(0.95);
+    });
+});
+// ─── getBlockRolePenalty ──────────────────────────────────────────────────────
+(0, globals_1.describe)('getBlockRolePenalty()', () => {
+    (0, globals_1.it)('no penalty when any blocker is MIDDLE_BLOCKER (1.00)', () => {
+        (0, globals_1.expect)((0, role_1.getBlockRolePenalty)([
+            [role_1.RoleEnum.MIDDLE_BLOCKER],
+            [role_1.RoleEnum.OUTSIDE_HITTER]
+        ])).toBeCloseTo(1.00);
+    });
+    (0, globals_1.it)('no penalty when all blockers are MB', () => {
+        (0, globals_1.expect)((0, role_1.getBlockRolePenalty)([
+            [role_1.RoleEnum.MIDDLE_BLOCKER],
+            [role_1.RoleEnum.MIDDLE_BLOCKER]
+        ])).toBeCloseTo(1.00);
+    });
+    (0, globals_1.it)('10% penalty when no blocker is MB (0.90)', () => {
+        (0, globals_1.expect)((0, role_1.getBlockRolePenalty)([
+            [role_1.RoleEnum.OUTSIDE_HITTER],
+            [role_1.RoleEnum.SETTER]
+        ])).toBeCloseTo(0.90);
+    });
+    (0, globals_1.it)('10% penalty for single non-MB blocker', () => {
+        (0, globals_1.expect)((0, role_1.getBlockRolePenalty)([[role_1.RoleEnum.OUTSIDE_HITTER]])).toBeCloseTo(0.90);
+    });
+    (0, globals_1.it)('no penalty if MB is a secondary role of any blocker', () => {
+        (0, globals_1.expect)((0, role_1.getBlockRolePenalty)([
+            [role_1.RoleEnum.OPPOSITE_HITTER, role_1.RoleEnum.MIDDLE_BLOCKER],
+            [role_1.RoleEnum.OUTSIDE_HITTER]
+        ])).toBeCloseTo(1.00);
+    });
+});

package/dist/cjs/src/service/player/schemas/performance-stats.z.d.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+export declare const PerformanceStatsInputSchema: z.ZodObject<{
+    attack: z.ZodNumber;
+    serve: z.ZodNumber;
+    reception: z.ZodNumber;
+    block: z.ZodNumber;
+    setting: z.ZodNumber;
+    defense: z.ZodNumber;
+    spike: z.ZodNumber;
+    quick: z.ZodNumber;
+    power: z.ZodNumber;
+    awareness: z.ZodNumber;
+    backAttack: z.ZodNumber;
+    overhand: z.ZodNumber;
+    bump: z.ZodNumber;
+    read: z.ZodNumber;
+    commit: z.ZodNumber;
+    focus: z.ZodNumber;
+    stamina: z.ZodNumber;
+    reflex: z.ZodNumber;
+}, z.core.$strip>;
+export type PerformanceStatsInput = z.infer<typeof PerformanceStatsInputSchema>;

package/dist/cjs/src/service/player/schemas/performance-stats.z.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PerformanceStatsInputSchema = void 0;
+const zod_1 = require("zod");
+const performance_stats_keys_1 = require("../performance-stats-keys");
+const statValueSchema = zod_1.z.number().int().min(1).max(99);
+const shape = Object.fromEntries(performance_stats_keys_1.performanceStatKeys.map((key) => [key, statValueSchema]));
+exports.PerformanceStatsInputSchema = zod_1.z.object(shape);

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

@@ -0,0 +1,155 @@
+import { z } from 'zod';
+import { Country } from '../../country';
+import { RoleEnum } from '../role';
+import { TraitEnum } from '../trait';
+import { RarityEnum } from '../rarity';
+import { DeclineProfileEnum } from '../decline';
+export declare const NameInputSchema: z.ZodObject<{
+    first: z.ZodString;
+    last: z.ZodString;
+}, z.core.$strip>;
+export declare const PlayerInputSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    name: z.ZodObject<{
+        first: z.ZodString;
+        last: z.ZodString;
+    }, z.core.$strip>;
+    country: z.ZodCustom<Country, Country>;
+    stats: z.ZodObject<{
+        attack: z.ZodNumber;
+        serve: z.ZodNumber;
+        reception: z.ZodNumber;
+        block: z.ZodNumber;
+        setting: z.ZodNumber;
+        defense: z.ZodNumber;
+        spike: z.ZodNumber;
+        quick: z.ZodNumber;
+        power: z.ZodNumber;
+        awareness: z.ZodNumber;
+        backAttack: z.ZodNumber;
+        overhand: z.ZodNumber;
+        bump: z.ZodNumber;
+        read: z.ZodNumber;
+        commit: z.ZodNumber;
+        focus: z.ZodNumber;
+        stamina: z.ZodNumber;
+        reflex: z.ZodNumber;
+    }, z.core.$strip>;
+    roles: z.ZodArray<z.ZodEnum<{
+        SETTER: RoleEnum.SETTER;
+        LIBERO: RoleEnum.LIBERO;
+        OUTSIDE_HITTER: RoleEnum.OUTSIDE_HITTER;
+        OPPOSITE_HITTER: RoleEnum.OPPOSITE_HITTER;
+        MIDDLE_BLOCKER: RoleEnum.MIDDLE_BLOCKER;
+    }>>;
+    traits: z.ZodArray<z.ZodEnum<{
+        MASTER_MIND: TraitEnum.MASTER_MIND;
+        MOVING_WALL: TraitEnum.MOVING_WALL;
+        SURPRISE_ATTACK: TraitEnum.SURPRISE_ATTACK;
+        MARKSMAN: TraitEnum.MARKSMAN;
+        METEOR_SERVE: TraitEnum.METEOR_SERVE;
+        VIGOROUS: TraitEnum.VIGOROUS;
+        GUARDIAN: TraitEnum.GUARDIAN;
+        FLOAT_SERVE: TraitEnum.FLOAT_SERVE;
+        DEFENSIVE_SPECIALIST: TraitEnum.DEFENSIVE_SPECIALIST;
+    }>>;
+    rarity: z.ZodEnum<{
+        COMMON: RarityEnum.COMMON;
+        RARE: RarityEnum.RARE;
+        LEGENDARY: RarityEnum.LEGENDARY;
+        MYTHIC: RarityEnum.MYTHIC;
+        SPECIAL: RarityEnum.SPECIAL;
+    }>;
+    age: z.ZodNumber;
+    declineProfile: z.ZodEnum<{
+        PRODIGY: DeclineProfileEnum.PRODIGY;
+        STANDARD: DeclineProfileEnum.STANDARD;
+        VETERAN: DeclineProfileEnum.VETERAN;
+        IRONMAN: DeclineProfileEnum.IRONMAN;
+    }>;
+    boxScores: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        playerId: z.ZodUUID;
+        matchSetId: z.ZodUUID;
+        attack: z.ZodObject<{
+            attempts: z.ZodNumber;
+            kills: z.ZodNumber;
+            errors: z.ZodNumber;
+        }, z.core.$strip>;
+        serve: z.ZodObject<{
+            attempts: z.ZodNumber;
+            aces: z.ZodNumber;
+            errors: z.ZodNumber;
+        }, z.core.$strip>;
+        reception: z.ZodObject<{
+            attempts: z.ZodNumber;
+            perfect: z.ZodNumber;
+            positive: z.ZodNumber;
+            overpasses: z.ZodNumber;
+            errors: z.ZodNumber;
+        }, z.core.$strip>;
+        block: z.ZodObject<{
+            solo: z.ZodNumber;
+            assists: z.ZodNumber;
+            errors: z.ZodNumber;
+            touches: z.ZodNumber;
+        }, z.core.$strip>;
+        setting: z.ZodObject<{
+            assists: z.ZodNumber;
+            errors: z.ZodNumber;
+            pass: z.ZodNumber;
+        }, z.core.$strip>;
+        defense: z.ZodObject<{
+            digs: z.ZodNumber;
+            errors: z.ZodNumber;
+        }, z.core.$strip>;
+        misc: z.ZodObject<{
+            pointsPlayed: z.ZodNumber;
+            pointsWonOnCourt: z.ZodNumber;
+            serveTurns: z.ZodNumber;
+            sideoutOpportunities: z.ZodNumber;
+            successfulSideouts: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>>>;
+    boxScoreTotals: z.ZodOptional<z.ZodObject<{
+        attack: z.ZodObject<{
+            attempts: z.ZodNumber;
+            kills: z.ZodNumber;
+            errors: z.ZodNumber;
+        }, z.core.$strip>;
+        serve: z.ZodObject<{
+            attempts: z.ZodNumber;
+            aces: z.ZodNumber;
+            errors: z.ZodNumber;
+        }, z.core.$strip>;
+        reception: z.ZodObject<{
+            attempts: z.ZodNumber;
+            perfect: z.ZodNumber;
+            positive: z.ZodNumber;
+            overpasses: z.ZodNumber;
+            errors: z.ZodNumber;
+        }, z.core.$strip>;
+        block: z.ZodObject<{
+            solo: z.ZodNumber;
+            assists: z.ZodNumber;
+            errors: z.ZodNumber;
+            touches: z.ZodNumber;
+        }, z.core.$strip>;
+        setting: z.ZodObject<{
+            assists: z.ZodNumber;
+            errors: z.ZodNumber;
+            pass: z.ZodNumber;
+        }, z.core.$strip>;
+        defense: z.ZodObject<{
+            digs: z.ZodNumber;
+            errors: z.ZodNumber;
+        }, z.core.$strip>;
+        misc: z.ZodObject<{
+            pointsPlayed: z.ZodNumber;
+            pointsWonOnCourt: z.ZodNumber;
+            serveTurns: z.ZodNumber;
+            sideoutOpportunities: z.ZodNumber;
+            successfulSideouts: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PlayerInput = z.infer<typeof PlayerInputSchema>;