volleyballsimtypes 0.0.356 → 0.0.358

package/dist/esm/src/service/match/match-set.js

@@ -0,0 +1,62 @@
+import { MatchTeam } from './match-team';
+import { MatchSetInputSchema } from './schemas/match-set.z';
+export class MatchSet {
+    static create(input) {
+        const result = MatchSetInputSchema.safeParse(input);
+        if (!result.success) {
+            throw new Error(`INVALID_MATCH_SET: ${result.error.message}. RECEIVED=${(() => { try {
+                return JSON.stringify(input);
+            }
+            catch {
+                return String(input);
+            } })()}`);
+        }
+        return new MatchSet(result.data);
+    }
+    constructor({ id, order, isTieBreak, homePlayerPosition, awayPlayerPosition, boxScores, rallies, homeScore, awayScore }) {
+        this.id = id;
+        this.order = order;
+        this._homeScore = homeScore;
+        this._awayScore = awayScore;
+        this.homePlayerPosition = homePlayerPosition;
+        this.awayPlayerPosition = awayPlayerPosition;
+        this.boxScores = boxScores;
+        this.rallies = rallies;
+        this.isTieBreak = isTieBreak;
+        this.scoreThreshold = isTieBreak ? 15 : 25;
+    }
+    get homeScore() {
+        return this._homeScore;
+    }
+    get awayScore() {
+        return this._awayScore;
+    }
+    increaseScore(team) {
+        if (team === MatchTeam.HOME)
+            this._homeScore++;
+        else if (team === MatchTeam.AWAY)
+            this._awayScore++;
+        else
+            throw new Error('UNKNOWN_TEAM');
+    }
+    addRally(rally) {
+        this.rallies.push(rally);
+    }
+    /**
+     * Has a team reached at least 25 points, and is the score difference between both teams at least 2?
+     * @returns boolean
+     */
+    isOver() {
+        return Math.abs(this.homeScore - this.awayScore) > 1 &&
+            (this.homeScore >= this.scoreThreshold || this.awayScore >= this.scoreThreshold);
+    }
+    /**
+     * Get the team that won the Set. Return undefined if set is not over.
+     * @returns CourtTeam
+     */
+    getWinner() {
+        if (!this.isOver())
+            throw new Error('UNFINISHED_SET');
+        return this.homeScore > this.awayScore ? MatchTeam.HOME : MatchTeam.AWAY;
+    }
+}

package/dist/esm/src/service/match/match-set.test.d.ts

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

package/dist/esm/src/service/match/match-set.test.js

@@ -0,0 +1,121 @@
+import { describe, it, expect } from '@jest/globals';
+import { v4 as uuidv4 } from 'uuid';
+import { MatchSet } from './match-set';
+import { MatchTeam } from './match-team';
+// ─── helpers ─────────────────────────────────────────────────────────────────
+function makeSet(homeScore, awayScore, isTieBreak = false, order) {
+    return MatchSet.create({
+        id: uuidv4(),
+        order: order ?? (isTieBreak ? 4 : 0),
+        isTieBreak,
+        homePlayerPosition: [],
+        awayPlayerPosition: [],
+        homeScore,
+        awayScore,
+        boxScores: [],
+        rallies: []
+    });
+}
+// ─── scoreThreshold ───────────────────────────────────────────────────────────
+describe('MatchSet', () => {
+    describe('scoreThreshold', () => {
+        it('is 25 for a regular set', () => {
+            expect(makeSet(0, 0).scoreThreshold).toBe(25);
+        });
+        it('is 15 for a tie-break set', () => {
+            expect(makeSet(0, 0, true).scoreThreshold).toBe(15);
+        });
+    });
+    // ─── isOver ──────────────────────────────────────────────────────────────────
+    describe('isOver()', () => {
+        it('returns false at 0-0', () => {
+            expect(makeSet(0, 0).isOver()).toBe(false);
+        });
+        it('returns false when home has 25 but lead is only 1 (25-24)', () => {
+            expect(makeSet(25, 24).isOver()).toBe(false);
+        });
+        it('returns false when away has 25 but lead is only 1 (24-25)', () => {
+            expect(makeSet(24, 25).isOver()).toBe(false);
+        });
+        it('returns true when home reaches 25 with a 2-point lead (25-23)', () => {
+            expect(makeSet(25, 23).isOver()).toBe(true);
+        });
+        it('returns true when away reaches 25 with a 2-point lead (23-25)', () => {
+            expect(makeSet(23, 25).isOver()).toBe(true);
+        });
+        it('returns true in overtime with 2-point lead (27-25)', () => {
+            expect(makeSet(27, 25).isOver()).toBe(true);
+        });
+        it('returns false in overtime deuce (26-25)', () => {
+            expect(makeSet(26, 25).isOver()).toBe(false);
+        });
+        it('returns false when neither team has reached 25 (20-18 via increaseScore)', () => {
+            // MatchSet.create() validates finished-set scores, so build mid-game state
+            // by starting at 0-0 and driving scores up with increaseScore().
+            const set = makeSet(0, 0);
+            for (let i = 0; i < 20; i++)
+                set.increaseScore(MatchTeam.HOME);
+            for (let i = 0; i < 18; i++)
+                set.increaseScore(MatchTeam.AWAY);
+            expect(set.isOver()).toBe(false);
+        });
+        it('returns false for tie-break at 0-0', () => {
+            expect(makeSet(0, 0, true).isOver()).toBe(false);
+        });
+        it('returns true for tie-break at 15-13 (2-point lead)', () => {
+            expect(makeSet(15, 13, true).isOver()).toBe(true);
+        });
+        it('returns false for tie-break at 15-14 (only 1 ahead)', () => {
+            expect(makeSet(15, 14, true).isOver()).toBe(false);
+        });
+        it('returns true for tie-break in overtime (17-15)', () => {
+            expect(makeSet(17, 15, true).isOver()).toBe(true);
+        });
+    });
+    // ─── getWinner ────────────────────────────────────────────────────────────────
+    describe('getWinner()', () => {
+        it('throws UNFINISHED_SET when set is not over', () => {
+            expect(() => makeSet(0, 0).getWinner()).toThrow('UNFINISHED_SET');
+        });
+        it('throws UNFINISHED_SET when score is tied at threshold (25-25)', () => {
+            // 25-25: diff is 0, not > 1
+            expect(() => makeSet(25, 25).getWinner()).toThrow('UNFINISHED_SET');
+        });
+        it('returns HOME when home score is higher', () => {
+            expect(makeSet(25, 20).getWinner()).toBe(MatchTeam.HOME);
+        });
+        it('returns AWAY when away score is higher', () => {
+            expect(makeSet(20, 25).getWinner()).toBe(MatchTeam.AWAY);
+        });
+        it('returns HOME for a tie-break win (15-13)', () => {
+            expect(makeSet(15, 13, true).getWinner()).toBe(MatchTeam.HOME);
+        });
+    });
+    // ─── increaseScore ────────────────────────────────────────────────────────────
+    describe('increaseScore()', () => {
+        it('increments home score by 1', () => {
+            const set = makeSet(0, 0);
+            set.increaseScore(MatchTeam.HOME);
+            expect(set.homeScore).toBe(1);
+            expect(set.awayScore).toBe(0);
+        });
+        it('increments away score by 1', () => {
+            const set = makeSet(0, 0);
+            set.increaseScore(MatchTeam.AWAY);
+            expect(set.awayScore).toBe(1);
+            expect(set.homeScore).toBe(0);
+        });
+        it('can be called multiple times', () => {
+            const set = makeSet(0, 0);
+            set.increaseScore(MatchTeam.HOME);
+            set.increaseScore(MatchTeam.HOME);
+            set.increaseScore(MatchTeam.AWAY);
+            expect(set.homeScore).toBe(2);
+            expect(set.awayScore).toBe(1);
+        });
+        it('throws UNKNOWN_TEAM for an invalid team value', () => {
+            const set = makeSet(0, 0);
+            expect(() => set.increaseScore('INVALID')).toThrow('UNKNOWN_TEAM');
+        });
+    });
+});

package/dist/esm/src/service/match/match-team.d.ts

@@ -0,0 +1,7 @@
+export declare enum MatchTeam {
+    HOME = "homeTeam",
+    AWAY = "awayTeam"
+}
+export declare namespace MatchTeam {
+    function otherTeam(team: MatchTeam): MatchTeam;
+}

package/dist/esm/src/service/match/match-team.js

@@ -0,0 +1,17 @@
+export var MatchTeam;
+(function (MatchTeam) {
+    MatchTeam["HOME"] = "homeTeam";
+    MatchTeam["AWAY"] = "awayTeam";
+})(MatchTeam || (MatchTeam = {}));
+// eslint-disable-next-line @typescript-eslint/no-namespace
+(function (MatchTeam) {
+    function otherTeam(team) {
+        if (team === MatchTeam.HOME)
+            return MatchTeam.AWAY;
+        else if (team === MatchTeam.AWAY)
+            return MatchTeam.HOME;
+        else
+            throw new Error('UNKNOWN_MATCH_TEAM');
+    }
+    MatchTeam.otherTeam = otherTeam;
+})(MatchTeam || (MatchTeam = {}));

package/dist/esm/src/service/match/match.d.ts

@@ -0,0 +1,26 @@
+import { MatchSet } from './match-set';
+import { Team } from '../team';
+import { MatchTeam } from './match-team';
+import { StatusEnum } from '../../data';
+import { VPER } from './vper';
+export type MatchScore = '3-0' | '3-1' | '3-2' | '2-3' | '1-3' | '0-3';
+export type SetScore = 0 | 1 | 2 | 3;
+export declare class Match {
+    readonly id: string;
+    readonly homeTeam: Team;
+    readonly awayTeam: Team;
+    readonly sets: MatchSet[];
+    readonly scheduledDate: Date;
+    readonly VPERs: VPER[];
+    status: StatusEnum;
+    homeScore?: number;
+    awayScore?: number;
+    winner?: Team;
+    static create(input: unknown): Match;
+    private constructor();
+    addSet(set: MatchSet): void;
+    getTeamSets(team: MatchTeam): SetScore;
+    getScore(): MatchScore;
+    isOver(): boolean;
+    getWinner(): Team;
+}

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

@@ -0,0 +1,61 @@
+import { MatchTeam } from './match-team';
+import { StatusEnum } from '../../data';
+import { MatchInputSchema } from './schemas/match.z';
+export class Match {
+    static create(input) {
+        const result = 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(MatchTeam.HOME)}-${this.getTeamSets(MatchTeam.AWAY)}`;
+    }
+    isOver() {
+        if (this.status === StatusEnum.COMPLETE)
+            return true;
+        const setsToWin = 3;
+        const homeSets = this.getTeamSets(MatchTeam.HOME);
+        const awaySets = this.getTeamSets(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(MatchTeam.HOME);
+        const awaySets = this.getTeamSets(MatchTeam.AWAY);
+        return homeSets > awaySets ? this.homeTeam : this.awayTeam;
+    }
+}

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

@@ -0,0 +1,15 @@
+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/esm/src/service/match/rally.js

@@ -0,0 +1,24 @@
+import { RallyInputSchema } from './schemas/rally.z';
+export class Rally {
+    static create(input) {
+        const result = 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);
+    }
+}

package/dist/esm/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/esm/src/service/match/schemas/box-score.z.js

@@ -0,0 +1,86 @@
+import { z } from 'zod';
+/**
+ * Helpers
+ */
+const nonNegInt = z.number().int().min(0);
+/**
+ * Leaf stat schemas
+ */
+export const AttackStatsSchema = 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'] });
+    }
+});
+export const ServeStatsSchema = 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'] });
+    }
+});
+export const ReceptionStatsSchema = 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'] });
+    }
+});
+export const BlockStatsSchema = 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'] });
+    }
+});
+export const SettingStatsSchema = z.object({
+    assists: nonNegInt,
+    errors: nonNegInt,
+    pass: nonNegInt
+});
+export const DefenseStatsSchema = z.object({
+    digs: nonNegInt,
+    errors: nonNegInt
+});
+export const MiscStatsSchema = 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
+ */
+export const BoxScoreInputSchema = z.object({
+    playerId: z.uuid(),
+    matchSetId: z.uuid(),
+    attack: AttackStatsSchema,
+    serve: ServeStatsSchema,
+    reception: ReceptionStatsSchema,
+    block: BlockStatsSchema,
+    setting: SettingStatsSchema,
+    defense: DefenseStatsSchema,
+    misc: MiscStatsSchema
+});

package/dist/esm/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/esm/src/service/match/schemas/match-rating.z.js

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { Match } from '../match';
+export const MatchContextSchema = z.discriminatedUnion('kind', [
+    z.object({
+        kind: z.literal('LEAGUE'),
+        tier: z.number().int().positive(),
+        homeIsBot: z.boolean(),
+        awayIsBot: z.boolean()
+    }),
+    z.object({
+        kind: z.literal('PROMOTION'),
+        upperTier: z.number().int().positive(),
+        lowerTier: z.number().int().positive(),
+        homeIsBot: z.boolean(),
+        awayIsBot: z.boolean()
+    }),
+    z.object({
+        kind: z.literal('QUALIFIER'),
+        homeIsBot: z.boolean(),
+        awayIsBot: z.boolean()
+    }),
+    z.object({
+        kind: z.literal('TOURNAMENT'),
+        homeIsBot: z.boolean(),
+        awayIsBot: z.boolean()
+    })
+]);
+export const MatchRatingInputSchema = z.object({
+    match: z.custom((v) => v instanceof Match, { message: 'INVALID_MATCH_INSTANCE' }),
+    context: MatchContextSchema
+});

package/dist/esm/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>;