volleyballsimtypes 0.0.217 → 0.0.358

package/dist/cjs/src/service/match/schemas/box-score.z.d.ts

@@ -0,0 +1,90 @@
+import { z } from 'zod';
+/**
+ * Leaf stat schemas
+ */
+export declare const AttackStatsSchema: z.ZodObject<{
+    attempts: z.ZodNumber;
+    kills: z.ZodNumber;
+    errors: z.ZodNumber;
+}, z.core.$strip>;
+export declare const ServeStatsSchema: z.ZodObject<{
+    attempts: z.ZodNumber;
+    aces: z.ZodNumber;
+    errors: z.ZodNumber;
+}, z.core.$strip>;
+export declare const ReceptionStatsSchema: z.ZodObject<{
+    attempts: z.ZodNumber;
+    perfect: z.ZodNumber;
+    positive: z.ZodNumber;
+    overpasses: z.ZodNumber;
+    errors: z.ZodNumber;
+}, z.core.$strip>;
+export declare const BlockStatsSchema: z.ZodObject<{
+    solo: z.ZodNumber;
+    assists: z.ZodNumber;
+    errors: z.ZodNumber;
+    touches: z.ZodNumber;
+}, z.core.$strip>;
+export declare const SettingStatsSchema: z.ZodObject<{
+    assists: z.ZodNumber;
+    errors: z.ZodNumber;
+    pass: z.ZodNumber;
+}, z.core.$strip>;
+export declare const DefenseStatsSchema: z.ZodObject<{
+    digs: z.ZodNumber;
+    errors: z.ZodNumber;
+}, z.core.$strip>;
+export declare const MiscStatsSchema: z.ZodObject<{
+    pointsPlayed: z.ZodNumber;
+    pointsWonOnCourt: z.ZodNumber;
+    serveTurns: z.ZodNumber;
+    sideoutOpportunities: z.ZodNumber;
+    successfulSideouts: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * BoxScore input schema
+ */
+export declare const BoxScoreInputSchema: 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>;
+export type BoxScoreInput = z.infer<typeof BoxScoreInputSchema>;

package/dist/cjs/src/service/match/schemas/box-score.z.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BoxScoreInputSchema = exports.MiscStatsSchema = exports.DefenseStatsSchema = exports.SettingStatsSchema = exports.BlockStatsSchema = exports.ReceptionStatsSchema = exports.ServeStatsSchema = exports.AttackStatsSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Helpers
+ */
+const nonNegInt = zod_1.z.number().int().min(0);
+/**
+ * Leaf stat schemas
+ */
+exports.AttackStatsSchema = zod_1.z.object({
+    attempts: nonNegInt,
+    kills: nonNegInt,
+    errors: nonNegInt
+}).superRefine((v, ctx) => {
+    if (v.errors > v.attempts) {
+        ctx.addIssue({ code: 'custom', message: 'ATTACK_ERRORS_EXCEEDS_ATTEMPTS', path: ['kills'] });
+    }
+});
+exports.ServeStatsSchema = zod_1.z.object({
+    attempts: nonNegInt,
+    aces: nonNegInt,
+    errors: nonNegInt
+}).superRefine((v, ctx) => {
+    if (v.aces + v.errors > v.attempts) {
+        ctx.addIssue({ code: 'custom', message: 'SERVE_ACES_PLUS_ERRORS_EXCEEDS_ATTEMPTS', path: ['aces'] });
+    }
+});
+exports.ReceptionStatsSchema = zod_1.z.object({
+    attempts: nonNegInt,
+    perfect: nonNegInt,
+    positive: nonNegInt,
+    overpasses: nonNegInt,
+    errors: nonNegInt
+}).superRefine((v, ctx) => {
+    const sum = v.perfect + v.positive + v.overpasses + v.errors;
+    if (sum > v.attempts) {
+        ctx.addIssue({ code: 'custom', message: 'RECEPTION_COMPONENTS_EXCEED_ATTEMPTS', path: ['attempts'] });
+    }
+});
+exports.BlockStatsSchema = zod_1.z.object({
+    solo: nonNegInt,
+    assists: nonNegInt,
+    errors: nonNegInt,
+    touches: nonNegInt
+}).superRefine((v, ctx) => {
+    // If you interpret touches as "block touches total", then point-scoring blocks can't exceed touches.
+    if (v.solo + v.assists > v.touches) {
+        ctx.addIssue({ code: 'custom', message: 'BLOCK_SOLO_PLUS_ASSISTS_EXCEEDS_TOUCHES', path: ['touches'] });
+    }
+});
+exports.SettingStatsSchema = zod_1.z.object({
+    assists: nonNegInt,
+    errors: nonNegInt,
+    pass: nonNegInt
+});
+exports.DefenseStatsSchema = zod_1.z.object({
+    digs: nonNegInt,
+    errors: nonNegInt
+});
+exports.MiscStatsSchema = zod_1.z.object({
+    pointsPlayed: nonNegInt,
+    pointsWonOnCourt: nonNegInt,
+    serveTurns: nonNegInt,
+    sideoutOpportunities: nonNegInt,
+    successfulSideouts: nonNegInt
+}).superRefine((v, ctx) => {
+    if (v.pointsWonOnCourt > v.pointsPlayed) {
+        ctx.addIssue({ code: 'custom', message: 'POINTS_WON_ON_COURT_EXCEEDS_POINTS_PLAYED', path: ['pointsWonOnCourt'] });
+    }
+    if (v.successfulSideouts > v.sideoutOpportunities) {
+        ctx.addIssue({ code: 'custom', message: 'SUCCESSFUL_SIDEOUTS_EXCEED_OPPORTUNITIES', path: ['successfulSideouts'] });
+    }
+});
+/**
+ * BoxScore input schema
+ */
+exports.BoxScoreInputSchema = zod_1.z.object({
+    playerId: zod_1.z.uuid(),
+    matchSetId: zod_1.z.uuid(),
+    attack: exports.AttackStatsSchema,
+    serve: exports.ServeStatsSchema,
+    reception: exports.ReceptionStatsSchema,
+    block: exports.BlockStatsSchema,
+    setting: exports.SettingStatsSchema,
+    defense: exports.DefenseStatsSchema,
+    misc: exports.MiscStatsSchema
+});

package/dist/cjs/src/service/match/schemas/match-rating.z.d.ts

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+import { Match } from '../match';
+export declare const MatchContextSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"LEAGUE">;
+    tier: z.ZodNumber;
+    homeIsBot: z.ZodBoolean;
+    awayIsBot: z.ZodBoolean;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"PROMOTION">;
+    upperTier: z.ZodNumber;
+    lowerTier: z.ZodNumber;
+    homeIsBot: z.ZodBoolean;
+    awayIsBot: z.ZodBoolean;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"QUALIFIER">;
+    homeIsBot: z.ZodBoolean;
+    awayIsBot: z.ZodBoolean;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"TOURNAMENT">;
+    homeIsBot: z.ZodBoolean;
+    awayIsBot: z.ZodBoolean;
+}, z.core.$strip>], "kind">;
+export declare const MatchRatingInputSchema: z.ZodObject<{
+    match: z.ZodCustom<Match, Match>;
+    context: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"LEAGUE">;
+        tier: z.ZodNumber;
+        homeIsBot: z.ZodBoolean;
+        awayIsBot: z.ZodBoolean;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"PROMOTION">;
+        upperTier: z.ZodNumber;
+        lowerTier: z.ZodNumber;
+        homeIsBot: z.ZodBoolean;
+        awayIsBot: z.ZodBoolean;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"QUALIFIER">;
+        homeIsBot: z.ZodBoolean;
+        awayIsBot: z.ZodBoolean;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"TOURNAMENT">;
+        homeIsBot: z.ZodBoolean;
+        awayIsBot: z.ZodBoolean;
+    }, z.core.$strip>], "kind">;
+}, z.core.$strip>;
+export type MatchContext = z.infer<typeof MatchContextSchema>;
+export type MatchRatingInput = z.infer<typeof MatchRatingInputSchema>;

package/dist/cjs/src/service/match/schemas/match-rating.z.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MatchRatingInputSchema = exports.MatchContextSchema = void 0;
+const zod_1 = require("zod");
+const match_1 = require("../match");
+exports.MatchContextSchema = zod_1.z.discriminatedUnion('kind', [
+    zod_1.z.object({
+        kind: zod_1.z.literal('LEAGUE'),
+        tier: zod_1.z.number().int().positive(),
+        homeIsBot: zod_1.z.boolean(),
+        awayIsBot: zod_1.z.boolean()
+    }),
+    zod_1.z.object({
+        kind: zod_1.z.literal('PROMOTION'),
+        upperTier: zod_1.z.number().int().positive(),
+        lowerTier: zod_1.z.number().int().positive(),
+        homeIsBot: zod_1.z.boolean(),
+        awayIsBot: zod_1.z.boolean()
+    }),
+    zod_1.z.object({
+        kind: zod_1.z.literal('QUALIFIER'),
+        homeIsBot: zod_1.z.boolean(),
+        awayIsBot: zod_1.z.boolean()
+    }),
+    zod_1.z.object({
+        kind: zod_1.z.literal('TOURNAMENT'),
+        homeIsBot: zod_1.z.boolean(),
+        awayIsBot: zod_1.z.boolean()
+    })
+]);
+exports.MatchRatingInputSchema = zod_1.z.object({
+    match: zod_1.z.custom((v) => v instanceof match_1.Match, { message: 'INVALID_MATCH_INSTANCE' }),
+    context: exports.MatchContextSchema
+});

package/dist/cjs/src/service/match/schemas/match-set.z.d.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { PlayerPosition, Rally } from '../rally';
+import { BoxScore } from '../box-score';
+export declare const MatchSetInputSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    order: z.ZodNumber;
+    isTieBreak: z.ZodBoolean;
+    homePlayerPosition: z.ZodArray<z.ZodCustom<PlayerPosition, PlayerPosition>>;
+    awayPlayerPosition: z.ZodArray<z.ZodCustom<PlayerPosition, PlayerPosition>>;
+    homeScore: z.ZodNumber;
+    awayScore: z.ZodNumber;
+    boxScores: z.ZodArray<z.ZodCustom<BoxScore, BoxScore>>;
+    rallies: z.ZodArray<z.ZodCustom<Rally, Rally>>;
+}, z.core.$strip>;
+export type MatchSetInput = z.infer<typeof MatchSetInputSchema>;

package/dist/cjs/src/service/match/schemas/match-set.z.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MatchSetInputSchema = void 0;
+const zod_1 = require("zod");
+const rally_1 = require("../rally");
+const box_score_1 = require("../box-score");
+const nonNegInt = zod_1.z.number().int().min(0);
+const orderSchema = zod_1.z.number().int().min(0).max(4);
+/**
+ * NOTE:
+ * This validates that the input contains actual instances of Rally / BoxScore.
+ * If you're validating plain JSON (e.g. from DB/API), swap these for object schemas.
+ */
+const PlayerPositionSchema = zod_1.z.custom((v) => v != null, {
+    message: 'INVALID_PLAYER_POSITION'
+});
+exports.MatchSetInputSchema = zod_1.z.object({
+    id: zod_1.z.uuid(),
+    order: orderSchema,
+    isTieBreak: zod_1.z.boolean(),
+    homePlayerPosition: zod_1.z.array(PlayerPositionSchema).max(12),
+    awayPlayerPosition: zod_1.z.array(PlayerPositionSchema).max(12),
+    homeScore: nonNegInt,
+    awayScore: nonNegInt,
+    boxScores: zod_1.z.array(zod_1.z.custom((v) => v instanceof box_score_1.BoxScore, {
+        message: 'INVALID_BOX_SCORE_INSTANCE'
+    })),
+    rallies: zod_1.z.array(zod_1.z.custom((v) => v instanceof rally_1.Rally, {
+        message: 'INVALID_RALLY_INSTANCE'
+    }))
+}).superRefine((data, ctx) => {
+    const { order, isTieBreak, rallies, homeScore, awayScore } = data;
+    // isTieBreak <-> order === 4
+    if (isTieBreak && order !== 4) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'TIEBREAK_REQUIRES_ORDER_4',
+            path: ['order']
+        });
+    }
+    if (!isTieBreak && order === 4) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'ORDER_4_REQUIRES_TIEBREAK',
+            path: ['isTieBreak']
+        });
+    }
+    const hasRallies = rallies.length > 0;
+    const isZeroZero = homeScore === 0 && awayScore === 0;
+    const scoreThreshold = isTieBreak ? 15 : 25;
+    // Score rule: one side must reach threshold, unless this is an empty-rallies 0-0 set.
+    if (!isZeroZero && homeScore < scoreThreshold && awayScore < scoreThreshold) {
+        ctx.addIssue({
+            code: 'custom',
+            message: isTieBreak ? 'SCORE_REQUIRES_SIDE_AT_LEAST_15' : 'SCORE_REQUIRES_SIDE_AT_LEAST_25',
+            path: ['homeScore']
+        });
+    }
+    // If rallies exist, score cannot be 0-0 and must match the number of rallies.
+    if (hasRallies) {
+        if (isZeroZero) {
+            ctx.addIssue({
+                code: 'custom',
+                message: 'NON_EMPTY_RALLIES_CANNOT_HAVE_0_0_SCORE',
+                path: ['rallies']
+            });
+        }
+        if (homeScore + awayScore !== rallies.length) {
+            ctx.addIssue({
+                code: 'custom',
+                message: 'RALLIES_LENGTH_MUST_EQUAL_SCORE_SUM',
+                path: ['rallies']
+            });
+        }
+    }
+});

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

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { Team } from '../../team';
+import { StatusEnum } from '../../../data/common';
+import { MatchSet } from '../match-set';
+import { VPER } from '../vper';
+export declare const MatchInputSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    homeTeam: z.ZodCustom<Team, Team>;
+    awayTeam: z.ZodCustom<Team, Team>;
+    scheduledDate: z.ZodCoercedDate<unknown>;
+    status: z.ZodEnum<{
+        PENDING: StatusEnum.PENDING;
+        IN_PROGRESS: StatusEnum.IN_PROGRESS;
+        COMPLETE: StatusEnum.COMPLETE;
+    }>;
+    sets: z.ZodOptional<z.ZodArray<z.ZodCustom<MatchSet, MatchSet>>>;
+    VPERs: z.ZodOptional<z.ZodArray<z.ZodCustom<VPER, VPER>>>;
+    homeScore: z.ZodOptional<z.ZodNumber>;
+    awayScore: z.ZodOptional<z.ZodNumber>;
+    winner: z.ZodOptional<z.ZodCustom<Team, Team>>;
+}, z.core.$strip>;
+export type MatchInput = z.infer<typeof MatchInputSchema>;

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

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MatchInputSchema = void 0;
+const zod_1 = require("zod");
+const team_1 = require("../../team");
+const common_1 = require("../../../data/common");
+const match_set_1 = require("../match-set");
+const vper_1 = require("../vper");
+const teamSchema = zod_1.z.custom((v) => v instanceof team_1.Team, {
+    message: 'INVALID_TEAM_INSTANCE'
+});
+exports.MatchInputSchema = zod_1.z.object({
+    id: zod_1.z.uuid(),
+    homeTeam: teamSchema,
+    awayTeam: teamSchema,
+    scheduledDate: zod_1.z.coerce.date(),
+    status: zod_1.z.enum(Object.values(common_1.StatusEnum)),
+    sets: zod_1.z.array(zod_1.z.custom((v) => v instanceof match_set_1.MatchSet, {
+        message: 'INVALID_MATCH_SET_INSTANCE'
+    })).optional(),
+    VPERs: zod_1.z.array(zod_1.z.custom((v) => v instanceof vper_1.VPER, {
+        message: 'INVALID_VPER_INSTANCE'
+    })).optional(),
+    homeScore: zod_1.z.number().int().optional(),
+    awayScore: zod_1.z.number().int().optional(),
+    winner: teamSchema.optional()
+}).superRefine((data, ctx) => {
+    if (data.homeTeam.id === data.awayTeam.id) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'HOME_AND_AWAY_TEAM_CANNOT_BE_EQUAL',
+            path: ['awayTeam', 'id']
+        });
+    }
+    if (data.sets !== undefined) {
+        const n = data.sets.length;
+        if (n !== 0 && (n < 3 || n > 5)) {
+            ctx.addIssue({
+                code: 'custom',
+                message: 'SETS_LENGTH_MUST_BE_0_OR_BETWEEN_3_AND_5',
+                path: ['sets']
+            });
+        }
+        if (n > 0 && data.status !== common_1.StatusEnum.COMPLETE) {
+            ctx.addIssue({
+                code: 'custom',
+                message: 'NON_EMPTY_SETS_REQUIRE_COMPLETE_MATCH',
+                path: ['sets']
+            });
+        }
+    }
+    const { status, homeScore, awayScore } = data;
+    if (status !== common_1.StatusEnum.COMPLETE) {
+        if (homeScore !== undefined && homeScore !== 0) {
+            ctx.addIssue({
+                code: 'custom',
+                message: 'HOME_SCORE_MUST_BE_0_WHEN_UNFINISHED',
+                path: ['homeScore']
+            });
+        }
+        if (awayScore !== undefined && awayScore !== 0) {
+            ctx.addIssue({
+                code: 'custom',
+                message: 'AWAY_SCORE_MUST_BE_0_WHEN_UNFINISHED',
+                path: ['awayScore']
+            });
+        }
+        return;
+    }
+    if (homeScore === undefined) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'HOME_SCORE_REQUIRED_WHEN_COMPLETE',
+            path: ['homeScore']
+        });
+    }
+    if (awayScore === undefined) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'AWAY_SCORE_REQUIRED_WHEN_COMPLETE',
+            path: ['awayScore']
+        });
+    }
+    if (homeScore === undefined || awayScore === undefined)
+        return;
+    if (homeScore < 0 || homeScore > 3) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'HOME_SCORE_OUT_OF_RANGE',
+            path: ['homeScore']
+        });
+    }
+    if (awayScore < 0 || awayScore > 3) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'AWAY_SCORE_OUT_OF_RANGE',
+            path: ['awayScore']
+        });
+    }
+    if (homeScore !== 3 && awayScore !== 3) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'MATCH_COMPLETE_REQUIRES_A_TEAM_TO_HAVE_3_SETS',
+            path: []
+        });
+    }
+});

package/dist/cjs/src/service/match/schemas/rally.z.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { RallyEvent } from '../../event';
+export declare const RallyInputSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    order: z.ZodNumber;
+    servingTeamId: z.ZodUUID;
+    events: z.ZodArray<z.ZodCustom<RallyEvent, RallyEvent>>;
+}, z.core.$strip>;
+export type RallyInput = z.infer<typeof RallyInputSchema>;

package/dist/cjs/src/service/match/schemas/rally.z.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RallyInputSchema = void 0;
+const zod_1 = require("zod");
+const event_1 = require("../../event");
+const nonNegInt = zod_1.z.number().int().min(0);
+exports.RallyInputSchema = zod_1.z.object({
+    id: zod_1.z.uuid(),
+    order: nonNegInt,
+    servingTeamId: zod_1.z.uuid(),
+    events: zod_1.z.array(zod_1.z.custom((v) => v instanceof event_1.RallyEvent, {
+        message: 'INVALID_RALLY_EVENT_INSTANCE'
+    }))
+});

package/dist/cjs/src/service/match/schemas/vper.z.d.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+export declare const VPERInputSchema: z.ZodObject<{
+    playerId: z.ZodUUID;
+    matchId: z.ZodUUID;
+    value: z.ZodNumber;
+}, z.core.$strip>;
+export type VPERInput = z.infer<typeof VPERInputSchema>;

package/dist/cjs/src/service/match/schemas/vper.z.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VPERInputSchema = void 0;
+const zod_1 = require("zod");
+exports.VPERInputSchema = zod_1.z.object({
+    playerId: zod_1.z.uuid(),
+    matchId: zod_1.z.uuid(),
+    value: zod_1.z.number().finite()
+});

package/dist/cjs/src/service/match/vper.d.ts

@@ -1,13 +1,14 @@
-import { BoxScore } from './box-score';
-export interface VPERParams {
-    readonly playerId: string;
-    readonly matchId: string;
-    readonly value: number;
-}
-export declare class VPER {
-    readonly playerId: string;
-    readonly matchId: string;
-    readonly value: number;
-    constructor({ playerId, matchId, value }: VPERParams);
-    static computeVPERForMatch(boxScores: BoxScore[]): number;
-}
+import { BoxScore } from './box-score';
+export interface VPERParams {
+    readonly playerId: string;
+    readonly matchId: string;
+    readonly value: number;
+}
+export declare class VPER {
+    readonly playerId: string;
+    readonly matchId: string;
+    readonly value: number;
+    static create(input: unknown): VPER;
+    private constructor();
+    static computeVPERForMatch(boxScores: BoxScore[]): number;
+}