volleyballsimtypes 0.0.358 → 0.0.359

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

@@ -1,65 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Match = void 0;
-const match_team_1 = require("./match-team");
-const data_1 = require("../../data");
-const match_z_1 = require("./schemas/match.z");
-class Match {
-    static create(input) {
-        const result = match_z_1.MatchInputSchema.safeParse(input);
-        if (!result.success) {
-            throw new Error(`INVALID_MATCH: ${result.error.message}. RECEIVED=${(() => { try {
-                return JSON.stringify(input);
-            }
-            catch {
-                return String(input);
-            } })()}`);
-        }
-        return new Match(result.data);
-    }
-    constructor({ id, homeTeam, awayTeam, scheduledDate, sets, status, homeScore, awayScore, winner, VPERs }) {
-        if (homeTeam.id === awayTeam.id)
-            throw new Error(`FAILED_TO_CREATE_MATCH. TEAMS_WITH_SAME_ID: ${homeTeam.id}`);
-        this.id = id;
-        this.homeTeam = homeTeam;
-        this.awayTeam = awayTeam;
-        this.scheduledDate = scheduledDate;
-        this.sets = sets ?? [];
-        this.status = status;
-        this.homeScore = homeScore;
-        this.awayScore = awayScore;
-        this.winner = winner;
-        this.VPERs = VPERs ?? [];
-    }
-    addSet(set) {
-        if (this.sets.length >= 5)
-            throw new Error('SET_AMOUNT_EXCEEDED');
-        this.sets.push(set);
-    }
-    getTeamSets(team) {
-        const sets = this.sets.reduce((sets, set) => sets + (!set.isOver() ? 0 : set.getWinner() === team ? 1 : 0), 0);
-        if (sets > 3 || sets < 0)
-            throw new Error(`INCORRECT_SET_VALUE: ${sets}`);
-        return sets;
-    }
-    getScore() {
-        return `${this.getTeamSets(match_team_1.MatchTeam.HOME)}-${this.getTeamSets(match_team_1.MatchTeam.AWAY)}`;
-    }
-    isOver() {
-        if (this.status === data_1.StatusEnum.COMPLETE)
-            return true;
-        const setsToWin = 3;
-        const homeSets = this.getTeamSets(match_team_1.MatchTeam.HOME);
-        const awaySets = this.getTeamSets(match_team_1.MatchTeam.AWAY);
-        return !(homeSets < setsToWin && awaySets < setsToWin);
-    }
-    getWinner() {
-        if (!this.isOver()) {
-            throw new Error(`UNFINISHED_MATCH: ${this.id}, homeSets=[${this.sets.map(s => s.homeScore).join(', ')}], awaySets=[${this.sets.map(s => s.awayScore).join(', ')}], status=${this.status}`);
-        }
-        const homeSets = this.getTeamSets(match_team_1.MatchTeam.HOME);
-        const awaySets = this.getTeamSets(match_team_1.MatchTeam.AWAY);
-        return homeSets > awaySets ? this.homeTeam : this.awayTeam;
-    }
-}
-exports.Match = Match;

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

@@ -1,15 +0,0 @@
-import { CourtPosition } from './court-position';
-import { RallyEvent } from '../event';
-export interface PlayerPosition {
-    position: CourtPosition;
-    playerId: string;
-}
-export declare class Rally {
-    readonly id: string;
-    readonly servingTeamId: string;
-    readonly events: RallyEvent[];
-    readonly order: number;
-    static create(input: unknown): Rally;
-    private constructor();
-    addEvent(event: RallyEvent): void;
-}

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

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Rally = void 0;
-const rally_z_1 = require("./schemas/rally.z");
-class Rally {
-    static create(input) {
-        const result = rally_z_1.RallyInputSchema.safeParse(input);
-        if (!result.success) {
-            throw new Error(`INVALID_RALLY: ${result.error.message}. RECEIVED=${(() => { try {
-                return JSON.stringify(input);
-            }
-            catch {
-                return String(input);
-            } })()}`);
-        }
-        return new Rally(result.data);
-    }
-    constructor({ id, order, servingTeamId, events }) {
-        this.id = id;
-        this.order = order;
-        this.servingTeamId = servingTeamId;
-        this.events = events;
-    }
-    addEvent(event) {
-        this.events.push(event);
-    }
-}
-exports.Rally = Rally;

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

@@ -1,90 +0,0 @@
-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

@@ -1,89 +0,0 @@
-"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

@@ -1,47 +0,0 @@
-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

@@ -1,34 +0,0 @@
-"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

@@ -1,15 +0,0 @@
-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

@@ -1,76 +0,0 @@
-"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

@@ -1,22 +0,0 @@
-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

@@ -1,107 +0,0 @@
-"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

@@ -1,9 +0,0 @@
-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

@@ -1,14 +0,0 @@
-"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

@@ -1,7 +0,0 @@
-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

@@ -1,9 +0,0 @@
-"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,14 +0,0 @@
-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;
-}