volleyballsimtypes 0.0.217 → 0.0.358

package/dist/esm/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/esm/src/service/player/schemas/performance-stats.z.js

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+import { performanceStatKeys } from '../performance-stats-keys';
+const statValueSchema = z.number().int().min(1).max(99);
+const shape = Object.fromEntries(performanceStatKeys.map((key) => [key, statValueSchema]));
+export const PerformanceStatsInputSchema = z.object(shape);

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

@@ -0,0 +1,147 @@
+import { z } from 'zod';
+import { Country } from '../../country';
+import { RoleEnum } from '../role';
+import { TraitEnum } from '../trait';
+import { RarityEnum } from '../rarity';
+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;
+    }>;
+    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>;

package/dist/esm/src/service/player/schemas/player.z.js

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+import { Country } from '../../country';
+import { RoleEnum } from '../role';
+import { TraitEnum } from '../trait';
+import { RarityEnum } from '../rarity';
+import { AttackStatsSchema, BlockStatsSchema, BoxScoreInputSchema, DefenseStatsSchema, MiscStatsSchema, ReceptionStatsSchema, ServeStatsSchema, SettingStatsSchema } from '../../match/schemas/box-score.z';
+import { PerformanceStatsInputSchema } from './performance-stats.z';
+export const NameInputSchema = z.object({
+    first: z.string().trim().min(1),
+    last: z.string().trim().min(1)
+});
+const countrySchema = z.custom((v) => v instanceof Country, {
+    message: 'INVALID_COUNTRY_INSTANCE'
+});
+const BoxScoreTotalsInputSchema = z.object({
+    attack: AttackStatsSchema,
+    serve: ServeStatsSchema,
+    reception: ReceptionStatsSchema,
+    block: BlockStatsSchema,
+    setting: SettingStatsSchema,
+    defense: DefenseStatsSchema,
+    misc: MiscStatsSchema
+});
+export const PlayerInputSchema = z.object({
+    id: z.uuid(),
+    name: NameInputSchema,
+    country: countrySchema,
+    stats: PerformanceStatsInputSchema,
+    roles: z.array(z.enum(Object.values(RoleEnum))).min(1),
+    traits: z.array(z.enum(Object.values(TraitEnum))),
+    rarity: z.enum(Object.values(RarityEnum)),
+    boxScores: z.array(BoxScoreInputSchema).optional(),
+    boxScoreTotals: BoxScoreTotalsInputSchema.optional()
+});

package/dist/esm/src/service/player/stats.d.ts

@@ -1,12 +1,12 @@
-import { PerformanceStats } from './performance-stats';
-export declare enum StatsEnum {
-    ATTACK = "ATTACK",
-    SET = "SET",
-    RECEIVE = "RECEIVE",
-    SERVE = "SERVE",
-    BLOCK = "BLOCK",
-    STAMINA = "STAMINA"
-}
-export type Stats = StatsEnum.ATTACK | StatsEnum.SET | StatsEnum.RECEIVE | StatsEnum.SERVE | StatsEnum.BLOCK | StatsEnum.STAMINA;
-export declare function calculateStatScore(performanceStats: PerformanceStats, statName: Stats): number;
-export declare function getMultipliers(statName: Stats, performanceStats?: PerformanceStats): any;
+import { PerformanceStats, PerformanceStatsKey } from './performance-stats';
+export declare enum StatsEnum {
+    ATTACK = "ATTACK",
+    SET = "SET",
+    RECEIVE = "RECEIVE",
+    SERVE = "SERVE",
+    BLOCK = "BLOCK",
+    STAMINA = "STAMINA"
+}
+export type Stats = StatsEnum.ATTACK | StatsEnum.SET | StatsEnum.RECEIVE | StatsEnum.SERVE | StatsEnum.BLOCK | StatsEnum.STAMINA;
+export declare function calculateStatScore(performanceStats: PerformanceStats, statName: Stats): number;
+export declare function getMultipliers(statName: Stats, performanceStats?: PerformanceStats): Partial<Record<PerformanceStatsKey, number>>;

package/dist/esm/src/service/player/stats.js

@@ -1,63 +1,63 @@
-export var StatsEnum;
-(function (StatsEnum) {
-    StatsEnum["ATTACK"] = "ATTACK";
-    StatsEnum["SET"] = "SET";
-    StatsEnum["RECEIVE"] = "RECEIVE";
-    StatsEnum["SERVE"] = "SERVE";
-    StatsEnum["BLOCK"] = "BLOCK";
-    StatsEnum["STAMINA"] = "STAMINA";
-})(StatsEnum || (StatsEnum = {}));
-export function calculateStatScore(performanceStats, statName) {
-    const multipliers = getMultipliers(statName, performanceStats);
-    const score = Object.entries(multipliers)
-        .reduce((total, [key, value]) => total + value * performanceStats[key], 0);
-    return Math.round(score);
-}
-export function getMultipliers(statName, performanceStats) {
-    switch (statName) {
-        case StatsEnum.ATTACK:
-            return {
-                spike: 0.55,
-                backAttack: 0.1,
-                power: performanceStats == null ? 0.125 : performanceStats.power > performanceStats.quick ? 0.2 : 0.05,
-                quick: performanceStats == null ? 0.125 : performanceStats.quick > performanceStats.power ? 0.2 : 0.05,
-                awareness: 0.05,
-                attack: 0.05
-            };
-        case StatsEnum.SET:
-            return {
-                setting: 0.75,
-                overhand: 0.1,
-                awareness: 0.075,
-                attack: 0.075
-            };
-        case StatsEnum.RECEIVE:
-            return {
-                reception: 0.75,
-                overhand: 0.015,
-                bump: 0.15,
-                focus: 0.015,
-                defense: 0.055,
-                reflex: 0.015
-            };
-        case StatsEnum.SERVE:
-            return {
-                serve: 0.85,
-                awareness: 0.075,
-                attack: 0.075
-            };
-        case StatsEnum.BLOCK:
-            return {
-                block: 0.65,
-                read: performanceStats == null ? 0.125 : performanceStats.read > performanceStats.commit ? 0.2 : 0.05,
-                commit: performanceStats == null ? 0.125 : performanceStats.commit > performanceStats.read ? 0.2 : 0.05,
-                focus: 0.04,
-                defense: 0.04,
-                reflex: 0.02
-            };
-        case StatsEnum.STAMINA:
-            return { stamina: 1 };
-        default:
-            throw new Error('INVALID_STAT');
-    }
-}
+export var StatsEnum;
+(function (StatsEnum) {
+    StatsEnum["ATTACK"] = "ATTACK";
+    StatsEnum["SET"] = "SET";
+    StatsEnum["RECEIVE"] = "RECEIVE";
+    StatsEnum["SERVE"] = "SERVE";
+    StatsEnum["BLOCK"] = "BLOCK";
+    StatsEnum["STAMINA"] = "STAMINA";
+})(StatsEnum || (StatsEnum = {}));
+export function calculateStatScore(performanceStats, statName) {
+    const multipliers = getMultipliers(statName, performanceStats);
+    const score = Object.entries(multipliers)
+        .reduce((total, [key, value]) => total + value * performanceStats[key], 0);
+    return Math.round(score);
+}
+export function getMultipliers(statName, performanceStats) {
+    switch (statName) {
+        case StatsEnum.ATTACK:
+            return {
+                spike: 0.55,
+                backAttack: 0.1,
+                power: performanceStats == null ? 0.125 : performanceStats.power > performanceStats.quick ? 0.2 : 0.05,
+                quick: performanceStats == null ? 0.125 : performanceStats.quick > performanceStats.power ? 0.2 : 0.05,
+                awareness: 0.05,
+                attack: 0.05
+            };
+        case StatsEnum.SET:
+            return {
+                setting: 0.75,
+                overhand: 0.1,
+                awareness: 0.075,
+                attack: 0.075
+            };
+        case StatsEnum.RECEIVE:
+            return {
+                reception: 0.75,
+                overhand: 0.015,
+                bump: 0.15,
+                focus: 0.015,
+                defense: 0.055,
+                reflex: 0.015
+            };
+        case StatsEnum.SERVE:
+            return {
+                serve: 0.85,
+                awareness: 0.075,
+                attack: 0.075
+            };
+        case StatsEnum.BLOCK:
+            return {
+                block: 0.65,
+                read: performanceStats == null ? 0.125 : performanceStats.read > performanceStats.commit ? 0.2 : 0.05,
+                commit: performanceStats == null ? 0.125 : performanceStats.commit > performanceStats.read ? 0.2 : 0.05,
+                focus: 0.04,
+                defense: 0.04,
+                reflex: 0.02
+            };
+        case StatsEnum.STAMINA:
+            return { stamina: 1 };
+        default:
+            throw new Error('INVALID_STAT');
+    }
+}

package/dist/esm/src/service/player/stats.test.d.ts

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

package/dist/esm/src/service/player/stats.test.js

@@ -0,0 +1,131 @@
+import { describe, it, expect } from '@jest/globals';
+import { calculateStatScore, getMultipliers, StatsEnum } from './stats';
+import { PerformanceStats } from './performance-stats';
+import { performanceStatKeys } from './performance-stats-keys';
+// ─── helpers ─────────────────────────────────────────────────────────────────
+/** Builds a PerformanceStats with all keys set to `base`, then applies overrides. */
+function makeStats(base = 50, overrides = {}) {
+    const data = Object.fromEntries(performanceStatKeys.map(k => [k, base]));
+    return PerformanceStats.create({ ...data, ...overrides });
+}
+// ─── getMultipliers ───────────────────────────────────────────────────────────
+describe('getMultipliers()', () => {
+    describe('ATTACK', () => {
+        it('boosts power weight (0.2) when power > quick', () => {
+            const m = getMultipliers(StatsEnum.ATTACK, makeStats(50, { power: 80, quick: 20 }));
+            expect(m.power).toBe(0.2);
+            expect(m.quick).toBe(0.05);
+        });
+        it('boosts quick weight (0.2) when quick > power', () => {
+            const m = getMultipliers(StatsEnum.ATTACK, makeStats(50, { quick: 80, power: 20 }));
+            expect(m.quick).toBe(0.2);
+            expect(m.power).toBe(0.05);
+        });
+        it('uses balanced weights (0.125) when performanceStats is omitted', () => {
+            const m = getMultipliers(StatsEnum.ATTACK);
+            expect(m.power).toBe(0.125);
+            expect(m.quick).toBe(0.125);
+        });
+        it('multipliers sum to 1 when power > quick', () => {
+            const m = getMultipliers(StatsEnum.ATTACK, makeStats(50, { power: 80, quick: 20 }));
+            const total = Object.values(m).reduce((s, v) => s + (v ?? 0), 0);
+            expect(total).toBeCloseTo(1, 10);
+        });
+    });
+    describe('SET', () => {
+        it('multipliers sum to 1', () => {
+            const m = getMultipliers(StatsEnum.SET);
+            const total = Object.values(m).reduce((s, v) => s + (v ?? 0), 0);
+            expect(total).toBeCloseTo(1, 10);
+        });
+        it('setting has the highest weight (0.75)', () => {
+            const m = getMultipliers(StatsEnum.SET);
+            const max = Math.max(...Object.values(m).map(v => v ?? 0));
+            expect(m.setting).toBe(max);
+        });
+    });
+    describe('RECEIVE', () => {
+        it('multipliers sum to 1', () => {
+            const m = getMultipliers(StatsEnum.RECEIVE);
+            const total = Object.values(m).reduce((s, v) => s + (v ?? 0), 0);
+            expect(total).toBeCloseTo(1, 10);
+        });
+        it('reception has the highest weight (0.75)', () => {
+            const m = getMultipliers(StatsEnum.RECEIVE);
+            const max = Math.max(...Object.values(m).map(v => v ?? 0));
+            expect(m.reception).toBe(max);
+        });
+    });
+    describe('SERVE', () => {
+        it('multipliers sum to 1', () => {
+            const m = getMultipliers(StatsEnum.SERVE);
+            const total = Object.values(m).reduce((s, v) => s + (v ?? 0), 0);
+            expect(total).toBeCloseTo(1, 10);
+        });
+        it('serve has the highest weight (0.85)', () => {
+            const m = getMultipliers(StatsEnum.SERVE);
+            const max = Math.max(...Object.values(m).map(v => v ?? 0));
+            expect(m.serve).toBe(max);
+        });
+    });
+    describe('BLOCK', () => {
+        it('boosts read weight (0.2) when read > commit', () => {
+            const m = getMultipliers(StatsEnum.BLOCK, makeStats(50, { read: 90, commit: 10 }));
+            expect(m.read).toBe(0.2);
+            expect(m.commit).toBe(0.05);
+        });
+        it('boosts commit weight (0.2) when commit > read', () => {
+            const m = getMultipliers(StatsEnum.BLOCK, makeStats(50, { commit: 90, read: 10 }));
+            expect(m.commit).toBe(0.2);
+            expect(m.read).toBe(0.05);
+        });
+        it('uses balanced weights (0.125) when performanceStats is omitted', () => {
+            const m = getMultipliers(StatsEnum.BLOCK);
+            expect(m.read).toBe(0.125);
+            expect(m.commit).toBe(0.125);
+        });
+        it('multipliers sum to 1 when read > commit', () => {
+            const m = getMultipliers(StatsEnum.BLOCK, makeStats(50, { read: 90, commit: 10 }));
+            const total = Object.values(m).reduce((s, v) => s + (v ?? 0), 0);
+            expect(total).toBeCloseTo(1, 10);
+        });
+    });
+    describe('STAMINA', () => {
+        it('returns exactly { stamina: 1 }', () => {
+            expect(getMultipliers(StatsEnum.STAMINA)).toEqual({ stamina: 1 });
+        });
+    });
+});
+// ─── calculateStatScore ───────────────────────────────────────────────────────
+describe('calculateStatScore()', () => {
+    it('STAMINA score equals the stamina stat value (weight 1.0)', () => {
+        expect(calculateStatScore(makeStats(1, { stamina: 77 }), StatsEnum.STAMINA)).toBe(77);
+    });
+    it('SET score equals stat value when all stats are uniform (multipliers sum to 1)', () => {
+        // setting*0.75 + overhand*0.1 + awareness*0.075 + attack*0.075 = s * 1.0
+        expect(calculateStatScore(makeStats(50), StatsEnum.SET)).toBe(50);
+    });
+    it('SERVE score equals stat value when all stats are uniform (multipliers sum to 1)', () => {
+        // serve*0.85 + awareness*0.075 + attack*0.075 = s * 1.0
+        expect(calculateStatScore(makeStats(50), StatsEnum.SERVE)).toBe(50);
+    });
+    it('RECEIVE score equals stat value when all stats are uniform (multipliers sum to 1)', () => {
+        // reception*0.75 + overhand*0.015 + bump*0.15 + focus*0.015 + defense*0.055 + reflex*0.015 = s * 1.0
+        expect(calculateStatScore(makeStats(50), StatsEnum.RECEIVE)).toBe(50);
+    });
+    it('always returns an integer (Math.round applied)', () => {
+        const score = calculateStatScore(makeStats(50), StatsEnum.SERVE);
+        expect(Number.isInteger(score)).toBe(true);
+    });
+    it('returns a higher score for a player with better relevant stats', () => {
+        const weak = calculateStatScore(makeStats(20), StatsEnum.SERVE);
+        const strong = calculateStatScore(makeStats(80), StatsEnum.SERVE);
+        expect(strong).toBeGreaterThan(weak);
+    });
+    it('SERVE: serve=99 dominates, contributing 0.85 of the total', () => {
+        // All other serve-relevant stats at 1: awareness=1, attack=1
+        // score ≈ 99*0.85 + 1*0.075 + 1*0.075 = 84.15 + 0.15 = 84.3 → 84
+        const stats = makeStats(1, { serve: 99 });
+        expect(calculateStatScore(stats, StatsEnum.SERVE)).toBe(84);
+    });
+});

package/dist/esm/src/service/player/trait.d.ts

@@ -1,51 +1,51 @@
-import { Rarity } from './rarity';
-import { Role } from './role';
-interface TraitProps {
-    readonly name: Trait;
-    readonly modifier: number;
-    readonly chance: number;
-    readonly roles: Role[];
-}
-export declare enum TraitEnum {
-    /**
-     * When triggered, all actions before the net crossing have a bonus.
-     * Can only be triggered during the first or second touch.
-     */
-    MASTER_MIND = "MASTER_MIND",
-    /**
-     * When this player is part of the front row, they will always be part of the blocking block
-     */
-    MOVING_WALL = "MOVING_WALL",
-    /**
-     * Enables the player making the second touch to spike or dump
-     */
-    SURPRISE_ATTACK = "SURPRISE_ATTACK",
-    /**
-     * Boosts the stat of the action taken and allows the player to choose the best target for the action.
-     */
-    MARKSMAN = "MARKSMAN",
-    /**
-     * The server will perform an extra strong serve.
-     */
-    METEOR_SERVE = "METEOR_SERVE",
-    /**
-     * The player has a 50% chance to perform an action with no energy decrease
-     */
-    VIGOROUS = "VIGOROUS",
-    /**
-     * The player with this trait has a chance to take the receiver's place if their reception stat is higher.
-     */
-    GUARDIAN = "GUARDIAN",
-    /**
-     * Enables the server to perform a float serve, which checks against receiver overhand instead.
-     */
-    FLOAT_SERVE = "FLOAT_SERVE",
-    /**
-     * Gives the player a chance to perform a perfect reception.
-     */
-    DEFENSIVE_SPECIALIST = "DEFENSIVE_SPECIALIST"
-}
-export type Trait = TraitEnum.FLOAT_SERVE | TraitEnum.SURPRISE_ATTACK | TraitEnum.GUARDIAN | TraitEnum.MASTER_MIND | TraitEnum.MOVING_WALL | TraitEnum.MARKSMAN | TraitEnum.METEOR_SERVE | TraitEnum.VIGOROUS | TraitEnum.DEFENSIVE_SPECIALIST;
-export declare function assignTraits(roles: Role[], rarity: Rarity): Trait[];
-export declare const traitMap: Map<Trait, TraitProps>;
-export {};
+import { Rarity } from './rarity';
+import { Role } from './role';
+interface TraitProps {
+    readonly name: Trait;
+    readonly modifier: number;
+    readonly chance: number;
+    readonly roles: Role[];
+}
+export declare enum TraitEnum {
+    /**
+     * When triggered, all actions before the net crossing have a bonus.
+     * Can only be triggered during the first or second touch.
+     */
+    MASTER_MIND = "MASTER_MIND",
+    /**
+     * When this player is part of the front row, they will always be part of the blocking block
+     */
+    MOVING_WALL = "MOVING_WALL",
+    /**
+     * Enables the player making the second touch to spike or dump
+     */
+    SURPRISE_ATTACK = "SURPRISE_ATTACK",
+    /**
+     * Boosts the stat of the action taken and allows the player to choose the best target for the action.
+     */
+    MARKSMAN = "MARKSMAN",
+    /**
+     * The server will perform an extra strong serve.
+     */
+    METEOR_SERVE = "METEOR_SERVE",
+    /**
+     * The player has a 50% chance to perform an action with no energy decrease
+     */
+    VIGOROUS = "VIGOROUS",
+    /**
+     * The player with this trait has a chance to take the receiver's place if their reception stat is higher.
+     */
+    GUARDIAN = "GUARDIAN",
+    /**
+     * Enables the server to perform a float serve, which checks against receiver overhand instead.
+     */
+    FLOAT_SERVE = "FLOAT_SERVE",
+    /**
+     * Gives the player a chance to perform a perfect reception.
+     */
+    DEFENSIVE_SPECIALIST = "DEFENSIVE_SPECIALIST"
+}
+export type Trait = TraitEnum.FLOAT_SERVE | TraitEnum.SURPRISE_ATTACK | TraitEnum.GUARDIAN | TraitEnum.MASTER_MIND | TraitEnum.MOVING_WALL | TraitEnum.MARKSMAN | TraitEnum.METEOR_SERVE | TraitEnum.VIGOROUS | TraitEnum.DEFENSIVE_SPECIALIST;
+export declare function assignTraits(roles: Role[], rarity: Rarity, maxTraits?: boolean): Trait[];
+export declare const traitMap: Map<Trait, TraitProps>;
+export {};