volleyballsimtypes 0.0.358 → 0.0.359

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

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

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

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

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

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

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

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

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

@@ -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/esm/src/service/match/rally.js

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

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

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

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

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

@@ -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>;