volleyballsimtypes 0.0.217 → 0.0.358

package/dist/cjs/src/service/event/libero-replacement.js

@@ -1,25 +1,38 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LiberoReplacement = exports.LiberoReplacementTypeEnum = void 0;
-const rally_event_1 = require("./rally-event");
-var LiberoReplacementTypeEnum;
-(function (LiberoReplacementTypeEnum) {
-    LiberoReplacementTypeEnum[LiberoReplacementTypeEnum["LIBERO_IN"] = 0] = "LIBERO_IN";
-    LiberoReplacementTypeEnum[LiberoReplacementTypeEnum["LIBERO_OUT"] = 1] = "LIBERO_OUT";
-})(LiberoReplacementTypeEnum = exports.LiberoReplacementTypeEnum || (exports.LiberoReplacementTypeEnum = {}));
-const eventType = rally_event_1.EventTypeEnum.LIBERO_REPLACEMENT;
-class LiberoReplacement extends rally_event_1.RallyEvent {
-    constructor({ playerId, type, libero }) {
-        super({ playerId, eventType });
-        this.type = type;
-        this.libero = libero;
-    }
-    toString() {
-        const playerId = `"playerId":"${this.playerId}"`;
-        const type = `"type":${this.type}`;
-        const eventType = `"eventType":${this.eventType}`;
-        const libero = `"libero":"${this.libero}"`;
-        return `{${playerId},${type},${eventType},${libero}}`;
-    }
-}
-exports.LiberoReplacement = LiberoReplacement;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiberoReplacement = exports.LiberoReplacementTypeEnum = void 0;
+const rally_event_1 = require("./rally-event");
+const libero_replacement_z_1 = require("./schemas/libero-replacement.z");
+var LiberoReplacementTypeEnum;
+(function (LiberoReplacementTypeEnum) {
+    LiberoReplacementTypeEnum[LiberoReplacementTypeEnum["LIBERO_IN"] = 0] = "LIBERO_IN";
+    LiberoReplacementTypeEnum[LiberoReplacementTypeEnum["LIBERO_OUT"] = 1] = "LIBERO_OUT";
+})(LiberoReplacementTypeEnum || (exports.LiberoReplacementTypeEnum = LiberoReplacementTypeEnum = {}));
+const eventType = rally_event_1.EventTypeEnum.LIBERO_REPLACEMENT;
+class LiberoReplacement extends rally_event_1.RallyEvent {
+    static create(input) {
+        const result = libero_replacement_z_1.LiberoReplacementInputSchema.safeParse(input);
+        if (!result.success) {
+            throw new Error(`INVALID_LIBERO_REPLACEMENT: ${result.error.message}. RECEIVED=${(() => { try {
+                return JSON.stringify(input);
+            }
+            catch {
+                return String(input);
+            } })()}`);
+        }
+        return new LiberoReplacement(result.data);
+    }
+    constructor({ playerId, type, libero }) {
+        super({ playerId, eventType });
+        this.type = type;
+        this.libero = libero;
+    }
+    toString() {
+        const playerId = `"playerId":"${this.playerId}"`;
+        const type = `"type":${this.type}`;
+        const eventType = `"eventType":${this.eventType}`;
+        const libero = `"libero":"${this.libero}"`;
+        return `{${playerId},${type},${eventType},${libero}}`;
+    }
+}
+exports.LiberoReplacement = LiberoReplacement;

package/dist/cjs/src/service/event/rally-event.d.ts

@@ -1,20 +1,20 @@
-export declare enum EventTypeEnum {
-    LIBERO_REPLACEMENT = 0,
-    SUBSTITUTION = 1,
-    SERVE = 2,
-    RECEPTION = 3,
-    SET = 4,
-    SPIKE = 5,
-    BLOCK = 6
-}
-export type EventType = EventTypeEnum.LIBERO_REPLACEMENT | EventTypeEnum.SUBSTITUTION | EventTypeEnum.SERVE | EventTypeEnum.RECEPTION | EventTypeEnum.SET | EventTypeEnum.SPIKE | EventTypeEnum.BLOCK;
-export interface RallyEventOpts {
-    readonly playerId: string;
-    readonly eventType: EventType;
-}
-export declare abstract class RallyEvent {
-    readonly playerId: string;
-    readonly eventType: EventType;
-    protected constructor({ eventType, playerId }: RallyEventOpts);
-    abstract toString(): string;
-}
+export declare enum EventTypeEnum {
+    LIBERO_REPLACEMENT = 0,
+    SUBSTITUTION = 1,
+    SERVE = 2,
+    RECEPTION = 3,
+    SET = 4,
+    SPIKE = 5,
+    BLOCK = 6
+}
+export type EventType = EventTypeEnum.LIBERO_REPLACEMENT | EventTypeEnum.SUBSTITUTION | EventTypeEnum.SERVE | EventTypeEnum.RECEPTION | EventTypeEnum.SET | EventTypeEnum.SPIKE | EventTypeEnum.BLOCK;
+export interface RallyEventOpts {
+    readonly playerId: string;
+    readonly eventType: EventType;
+}
+export declare abstract class RallyEvent {
+    readonly playerId: string;
+    readonly eventType: EventType;
+    protected constructor({ eventType, playerId }: RallyEventOpts);
+    abstract toString(): string;
+}

package/dist/cjs/src/service/event/rally-event.js

@@ -1,20 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RallyEvent = exports.EventTypeEnum = void 0;
-var EventTypeEnum;
-(function (EventTypeEnum) {
-    EventTypeEnum[EventTypeEnum["LIBERO_REPLACEMENT"] = 0] = "LIBERO_REPLACEMENT";
-    EventTypeEnum[EventTypeEnum["SUBSTITUTION"] = 1] = "SUBSTITUTION";
-    EventTypeEnum[EventTypeEnum["SERVE"] = 2] = "SERVE";
-    EventTypeEnum[EventTypeEnum["RECEPTION"] = 3] = "RECEPTION";
-    EventTypeEnum[EventTypeEnum["SET"] = 4] = "SET";
-    EventTypeEnum[EventTypeEnum["SPIKE"] = 5] = "SPIKE";
-    EventTypeEnum[EventTypeEnum["BLOCK"] = 6] = "BLOCK";
-})(EventTypeEnum = exports.EventTypeEnum || (exports.EventTypeEnum = {}));
-class RallyEvent {
-    constructor({ eventType, playerId }) {
-        this.playerId = playerId;
-        this.eventType = eventType;
-    }
-}
-exports.RallyEvent = RallyEvent;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RallyEvent = exports.EventTypeEnum = void 0;
+var EventTypeEnum;
+(function (EventTypeEnum) {
+    EventTypeEnum[EventTypeEnum["LIBERO_REPLACEMENT"] = 0] = "LIBERO_REPLACEMENT";
+    EventTypeEnum[EventTypeEnum["SUBSTITUTION"] = 1] = "SUBSTITUTION";
+    EventTypeEnum[EventTypeEnum["SERVE"] = 2] = "SERVE";
+    EventTypeEnum[EventTypeEnum["RECEPTION"] = 3] = "RECEPTION";
+    EventTypeEnum[EventTypeEnum["SET"] = 4] = "SET";
+    EventTypeEnum[EventTypeEnum["SPIKE"] = 5] = "SPIKE";
+    EventTypeEnum[EventTypeEnum["BLOCK"] = 6] = "BLOCK";
+})(EventTypeEnum || (exports.EventTypeEnum = EventTypeEnum = {}));
+class RallyEvent {
+    constructor({ eventType, playerId }) {
+        this.playerId = playerId;
+        this.eventType = eventType;
+    }
+}
+exports.RallyEvent = RallyEvent;

package/dist/cjs/src/service/event/reception.d.ts

@@ -1,33 +1,23 @@
-import { CourtTarget } from '../match';
-import { Trait } from '../player';
-import { InPlayEvent } from './in-play-event';
-export declare enum ReceptionTypeEnum {
-    DIG = 0,
-    OVERHAND = 1,
-    ONE_HAND = 2,
-    OTHER_BODY_PART = 3
-}
-export type ReceptionType = ReceptionTypeEnum.DIG | ReceptionTypeEnum.OVERHAND | ReceptionTypeEnum.ONE_HAND | ReceptionTypeEnum.OTHER_BODY_PART;
-export declare enum ReceptionFailureEnum {
-    NO_FAILURE = 0,
-    FAULT = 1,
-    MISS = 2,
-    OUT_OF_BOUNDS = 3,
-    BAD_PASS = 4
-}
-export type ReceptionFailure = ReceptionFailureEnum.NO_FAILURE | ReceptionFailureEnum.FAULT | ReceptionFailureEnum.MISS | ReceptionFailureEnum.OUT_OF_BOUNDS | ReceptionFailureEnum.BAD_PASS;
-interface ReceptionOpts {
-    readonly type: ReceptionType;
-    readonly failure: ReceptionFailure;
-    readonly target: CourtTarget;
-    readonly score: number;
-    readonly activeTraits: Trait[];
-    readonly playerId: string;
-}
-export declare class Reception extends InPlayEvent<ReceptionFailure, ReceptionType> {
-    readonly failure: ReceptionFailure;
-    readonly type: ReceptionType;
-    constructor({ score, playerId, target, failure, type, activeTraits }: ReceptionOpts);
-    toString(): string;
-}
-export {};
+import { InPlayEvent } from './in-play-event';
+export declare enum ReceptionTypeEnum {
+    DIG = 0,
+    OVERHAND = 1,
+    ONE_HAND = 2,
+    OTHER_BODY_PART = 3
+}
+export type ReceptionType = ReceptionTypeEnum.DIG | ReceptionTypeEnum.OVERHAND | ReceptionTypeEnum.ONE_HAND | ReceptionTypeEnum.OTHER_BODY_PART;
+export declare enum ReceptionFailureEnum {
+    NO_FAILURE = 0,
+    FAULT = 1,
+    MISS = 2,
+    OUT_OF_BOUNDS = 3,
+    BAD_PASS = 4
+}
+export type ReceptionFailure = ReceptionFailureEnum.NO_FAILURE | ReceptionFailureEnum.FAULT | ReceptionFailureEnum.MISS | ReceptionFailureEnum.OUT_OF_BOUNDS | ReceptionFailureEnum.BAD_PASS;
+export declare class Reception extends InPlayEvent<ReceptionFailure, ReceptionType> {
+    readonly failure: ReceptionFailure;
+    readonly type: ReceptionType;
+    static create(input: unknown): Reception;
+    private constructor();
+    toString(): string;
+}

package/dist/cjs/src/service/event/reception.js

@@ -1,34 +1,47 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Reception = exports.ReceptionFailureEnum = exports.ReceptionTypeEnum = void 0;
-const rally_event_1 = require("./rally-event");
-const in_play_event_1 = require("./in-play-event");
-var ReceptionTypeEnum;
-(function (ReceptionTypeEnum) {
-    ReceptionTypeEnum[ReceptionTypeEnum["DIG"] = 0] = "DIG";
-    ReceptionTypeEnum[ReceptionTypeEnum["OVERHAND"] = 1] = "OVERHAND";
-    ReceptionTypeEnum[ReceptionTypeEnum["ONE_HAND"] = 2] = "ONE_HAND";
-    ReceptionTypeEnum[ReceptionTypeEnum["OTHER_BODY_PART"] = 3] = "OTHER_BODY_PART";
-})(ReceptionTypeEnum = exports.ReceptionTypeEnum || (exports.ReceptionTypeEnum = {}));
-var ReceptionFailureEnum;
-(function (ReceptionFailureEnum) {
-    ReceptionFailureEnum[ReceptionFailureEnum["NO_FAILURE"] = 0] = "NO_FAILURE";
-    ReceptionFailureEnum[ReceptionFailureEnum["FAULT"] = 1] = "FAULT";
-    ReceptionFailureEnum[ReceptionFailureEnum["MISS"] = 2] = "MISS";
-    ReceptionFailureEnum[ReceptionFailureEnum["OUT_OF_BOUNDS"] = 3] = "OUT_OF_BOUNDS";
-    ReceptionFailureEnum[ReceptionFailureEnum["BAD_PASS"] = 4] = "BAD_PASS";
-})(ReceptionFailureEnum = exports.ReceptionFailureEnum || (exports.ReceptionFailureEnum = {}));
-const eventType = rally_event_1.EventTypeEnum.RECEPTION;
-class Reception extends in_play_event_1.InPlayEvent {
-    constructor({ score, playerId, target, failure, type, activeTraits }) {
-        super({ score, playerId, target, activeTraits, eventType });
-        this.type = type;
-        this.failure = failure;
-    }
-    toString() {
-        const failure = `"failure":${this.failure}`;
-        const type = `"type":${this.type}`;
-        return `{${this._toString()},${failure},${type}}`;
-    }
-}
-exports.Reception = Reception;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Reception = exports.ReceptionFailureEnum = exports.ReceptionTypeEnum = void 0;
+const rally_event_1 = require("./rally-event");
+const in_play_event_1 = require("./in-play-event");
+const reception_z_1 = require("./schemas/reception.z");
+var ReceptionTypeEnum;
+(function (ReceptionTypeEnum) {
+    ReceptionTypeEnum[ReceptionTypeEnum["DIG"] = 0] = "DIG";
+    ReceptionTypeEnum[ReceptionTypeEnum["OVERHAND"] = 1] = "OVERHAND";
+    ReceptionTypeEnum[ReceptionTypeEnum["ONE_HAND"] = 2] = "ONE_HAND";
+    ReceptionTypeEnum[ReceptionTypeEnum["OTHER_BODY_PART"] = 3] = "OTHER_BODY_PART";
+})(ReceptionTypeEnum || (exports.ReceptionTypeEnum = ReceptionTypeEnum = {}));
+var ReceptionFailureEnum;
+(function (ReceptionFailureEnum) {
+    ReceptionFailureEnum[ReceptionFailureEnum["NO_FAILURE"] = 0] = "NO_FAILURE";
+    ReceptionFailureEnum[ReceptionFailureEnum["FAULT"] = 1] = "FAULT";
+    ReceptionFailureEnum[ReceptionFailureEnum["MISS"] = 2] = "MISS";
+    ReceptionFailureEnum[ReceptionFailureEnum["OUT_OF_BOUNDS"] = 3] = "OUT_OF_BOUNDS";
+    ReceptionFailureEnum[ReceptionFailureEnum["BAD_PASS"] = 4] = "BAD_PASS";
+})(ReceptionFailureEnum || (exports.ReceptionFailureEnum = ReceptionFailureEnum = {}));
+const eventType = rally_event_1.EventTypeEnum.RECEPTION;
+class Reception extends in_play_event_1.InPlayEvent {
+    static create(input) {
+        const result = reception_z_1.ReceptionInputSchema.safeParse(input);
+        if (!result.success) {
+            throw new Error(`INVALID_RECEPTION: ${result.error.message}. RECEIVED=${(() => { try {
+                return JSON.stringify(input);
+            }
+            catch {
+                return String(input);
+            } })()}`);
+        }
+        return new Reception(result.data);
+    }
+    constructor({ score, playerId, target, failure, type, activeTraits }) {
+        super({ score, playerId, target, activeTraits, eventType });
+        this.type = type;
+        this.failure = failure;
+    }
+    toString() {
+        const failure = `"failure":${this.failure}`;
+        const type = `"type":${this.type}`;
+        return `{${this._toString()},${failure},${type}}`;
+    }
+}
+exports.Reception = Reception;

package/dist/cjs/src/service/event/schemas/block.z.d.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { TraitEnum } from '../../player';
+export declare const BlockInputSchema: z.ZodObject<{
+    playerId: z.ZodUUID;
+    score: z.ZodNumber;
+    target: z.ZodNumber;
+    activeTraits: 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;
+    }>>;
+    failure: z.ZodNumber;
+    type: z.ZodNumber;
+    blockers: z.ZodArray<z.ZodUUID>;
+}, z.core.$strip>;
+export type BlockInput = z.infer<typeof BlockInputSchema>;

package/dist/cjs/src/service/event/schemas/block.z.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockInputSchema = void 0;
+const zod_1 = require("zod");
+const player_1 = require("../../player");
+const blockTypeValues = [0, 1, 2, 3];
+const blockFailureValues = [0, 1, 2, 3, 4, 5];
+const courtTargetValues = Array.from({ length: 13 }, (_, i) => i);
+exports.BlockInputSchema = zod_1.z.object({
+    playerId: zod_1.z.uuid(),
+    score: zod_1.z.number().finite(),
+    target: zod_1.z.number().int().refine((v) => courtTargetValues.includes(v), { message: 'INVALID_COURT_TARGET' }),
+    activeTraits: zod_1.z.array(zod_1.z.enum(Object.values(player_1.TraitEnum))),
+    failure: zod_1.z.number().int().refine((v) => blockFailureValues.includes(v), { message: 'INVALID_BLOCK_FAILURE' }),
+    type: zod_1.z.number().int().refine((v) => blockTypeValues.includes(v), { message: 'INVALID_BLOCK_TYPE' }),
+    blockers: zod_1.z.array(zod_1.z.uuid())
+});

package/dist/cjs/src/service/event/schemas/libero-replacement.z.d.ts

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

package/dist/cjs/src/service/event/schemas/libero-replacement.z.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiberoReplacementInputSchema = void 0;
+const zod_1 = require("zod");
+const liberoReplacementTypeValues = [0, 1];
+exports.LiberoReplacementInputSchema = zod_1.z.object({
+    playerId: zod_1.z.uuid(),
+    libero: zod_1.z.uuid(),
+    type: zod_1.z.number().int().refine((v) => liberoReplacementTypeValues.includes(v), {
+        message: 'INVALID_LIBERO_REPLACEMENT_TYPE'
+    })
+}).superRefine((data, ctx) => {
+    if (data.playerId === data.libero) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'LIBERO_REPLACEMENT_PLAYER_IN_AND_OUT_CANNOT_BE_EQUAL',
+            path: ['libero']
+        });
+    }
+});

package/dist/cjs/src/service/event/schemas/reception.z.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { TraitEnum } from '../../player';
+export declare const ReceptionInputSchema: z.ZodObject<{
+    playerId: z.ZodUUID;
+    score: z.ZodNumber;
+    target: z.ZodNumber;
+    activeTraits: 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;
+    }>>;
+    failure: z.ZodNumber;
+    type: z.ZodNumber;
+}, z.core.$strip>;
+export type ReceptionInput = z.infer<typeof ReceptionInputSchema>;

package/dist/cjs/src/service/event/schemas/reception.z.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReceptionInputSchema = void 0;
+const zod_1 = require("zod");
+const player_1 = require("../../player");
+const receptionTypeValues = [0, 1, 2, 3];
+const receptionFailureValues = [0, 1, 2, 3, 4];
+const courtTargetValues = Array.from({ length: 13 }, (_, i) => i);
+exports.ReceptionInputSchema = zod_1.z.object({
+    playerId: zod_1.z.uuid(),
+    score: zod_1.z.number().finite(),
+    target: zod_1.z.number().int().refine((v) => courtTargetValues.includes(v), { message: 'INVALID_COURT_TARGET' }),
+    activeTraits: zod_1.z.array(zod_1.z.enum(Object.values(player_1.TraitEnum))),
+    failure: zod_1.z.number().int().refine((v) => receptionFailureValues.includes(v), { message: 'INVALID_RECEPTION_FAILURE' }),
+    type: zod_1.z.number().int().refine((v) => receptionTypeValues.includes(v), { message: 'INVALID_RECEPTION_TYPE' })
+});

package/dist/cjs/src/service/event/schemas/serve.z.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { TraitEnum } from '../../player';
+export declare const ServeInputSchema: z.ZodObject<{
+    playerId: z.ZodUUID;
+    score: z.ZodNumber;
+    target: z.ZodNumber;
+    activeTraits: 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;
+    }>>;
+    failure: z.ZodNumber;
+    type: z.ZodNumber;
+}, z.core.$strip>;
+export type ServeInput = z.infer<typeof ServeInputSchema>;

package/dist/cjs/src/service/event/schemas/serve.z.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServeInputSchema = void 0;
+const zod_1 = require("zod");
+const player_1 = require("../../player");
+const serveTypeValues = [0, 1, 2, 3];
+const serveFailureValues = [0, 1, 2, 3, 4];
+const courtTargetValues = Array.from({ length: 13 }, (_, i) => i);
+exports.ServeInputSchema = zod_1.z.object({
+    playerId: zod_1.z.uuid(),
+    score: zod_1.z.number().finite(),
+    target: zod_1.z.number().int().refine((v) => courtTargetValues.includes(v), { message: 'INVALID_COURT_TARGET' }),
+    activeTraits: zod_1.z.array(zod_1.z.enum(Object.values(player_1.TraitEnum))),
+    failure: zod_1.z.number().int().refine((v) => serveFailureValues.includes(v), { message: 'INVALID_SERVE_FAILURE' }),
+    type: zod_1.z.number().int().refine((v) => serveTypeValues.includes(v), { message: 'INVALID_SERVE_TYPE' })
+});

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

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { TraitEnum } from '../../player';
+export declare const SetInputSchema: z.ZodObject<{
+    playerId: z.ZodUUID;
+    score: z.ZodNumber;
+    target: z.ZodNumber;
+    activeTraits: 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;
+    }>>;
+    failure: z.ZodNumber;
+    type: z.ZodNumber;
+}, z.core.$strip>;
+export type SetInput = z.infer<typeof SetInputSchema>;

package/dist/cjs/src/service/event/schemas/set.z.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetInputSchema = void 0;
+const zod_1 = require("zod");
+const player_1 = require("../../player");
+const setTypeValues = [0, 1];
+const setFailureValues = [0, 1, 2, 3, 4];
+const courtTargetValues = Array.from({ length: 13 }, (_, i) => i);
+exports.SetInputSchema = zod_1.z.object({
+    playerId: zod_1.z.uuid(),
+    score: zod_1.z.number().finite(),
+    target: zod_1.z.number().int().refine((v) => courtTargetValues.includes(v), { message: 'INVALID_COURT_TARGET' }),
+    activeTraits: zod_1.z.array(zod_1.z.enum(Object.values(player_1.TraitEnum))),
+    failure: zod_1.z.number().int().refine((v) => setFailureValues.includes(v), { message: 'INVALID_SET_FAILURE' }),
+    type: zod_1.z.number().int().refine((v) => setTypeValues.includes(v), { message: 'INVALID_SET_TYPE' })
+});

package/dist/cjs/src/service/event/schemas/spike.z.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { TraitEnum } from '../../player';
+export declare const SpikeInputSchema: z.ZodObject<{
+    playerId: z.ZodUUID;
+    score: z.ZodNumber;
+    target: z.ZodNumber;
+    activeTraits: 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;
+    }>>;
+    failure: z.ZodNumber;
+    type: z.ZodNumber;
+}, z.core.$strip>;
+export type SpikeInput = z.infer<typeof SpikeInputSchema>;

package/dist/cjs/src/service/event/schemas/spike.z.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpikeInputSchema = void 0;
+const zod_1 = require("zod");
+const player_1 = require("../../player");
+const spikeTypeValues = [0, 1, 2, 3, 4, 5];
+const spikeFailureValues = [0, 1, 2, 3, 4];
+const courtTargetValues = Array.from({ length: 13 }, (_, i) => i);
+exports.SpikeInputSchema = zod_1.z.object({
+    playerId: zod_1.z.uuid(),
+    score: zod_1.z.number().finite(),
+    target: zod_1.z.number().int().refine((v) => courtTargetValues.includes(v), { message: 'INVALID_COURT_TARGET' }),
+    activeTraits: zod_1.z.array(zod_1.z.enum(Object.values(player_1.TraitEnum))),
+    failure: zod_1.z.number().int().refine((v) => spikeFailureValues.includes(v), { message: 'INVALID_SPIKE_FAILURE' }),
+    type: zod_1.z.number().int().refine((v) => spikeTypeValues.includes(v), { message: 'INVALID_SPIKE_TYPE' })
+});

package/dist/cjs/src/service/event/schemas/substitution.z.d.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+export declare const SubstitutionInputSchema: z.ZodObject<{
+    playerId: z.ZodUUID;
+    playerOut: z.ZodUUID;
+}, z.core.$strip>;
+export type SubstitutionInput = z.infer<typeof SubstitutionInputSchema>;

package/dist/cjs/src/service/event/schemas/substitution.z.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubstitutionInputSchema = void 0;
+const zod_1 = require("zod");
+exports.SubstitutionInputSchema = zod_1.z.object({
+    playerId: zod_1.z.uuid(),
+    playerOut: zod_1.z.uuid()
+}).superRefine((data, ctx) => {
+    if (data.playerId === data.playerOut) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'SUBSTITUTION_PLAYER_IN_AND_OUT_CANNOT_BE_EQUAL',
+            path: ['playerOut']
+        });
+    }
+});

package/dist/cjs/src/service/event/serve.d.ts

@@ -1,33 +1,23 @@
-import { CourtTarget } from '../match';
-import { Trait } from '../player';
-import { InPlayEvent } from './in-play-event';
-export declare enum ServeTypeEnum {
-    OVERHAND_TOPSPIN = 0,
-    OVERHAND_FLOAT = 1,
-    JUMP_TOPSPIN = 2,
-    JUMP_FLOAT = 3
-}
-export type ServeType = ServeTypeEnum.OVERHAND_TOPSPIN | ServeTypeEnum.OVERHAND_FLOAT | ServeTypeEnum.JUMP_TOPSPIN | ServeTypeEnum.JUMP_FLOAT;
-export declare enum ServeFailureEnum {
-    NO_FAILURE = 0,
-    FAULT = 1,
-    MISS = 2,
-    NET = 3,
-    OUT_OF_BOUNDS = 4
-}
-export type ServeFailure = ServeFailureEnum.NO_FAILURE | ServeFailureEnum.FAULT | ServeFailureEnum.MISS | ServeFailureEnum.NET | ServeFailureEnum.OUT_OF_BOUNDS;
-interface ServeOpts {
-    readonly type: ServeType;
-    readonly failure: ServeFailure;
-    readonly target: CourtTarget;
-    readonly score: number;
-    readonly activeTraits: Trait[];
-    readonly playerId: string;
-}
-export declare class Serve extends InPlayEvent<ServeFailure, ServeType> {
-    readonly failure: ServeFailure;
-    readonly type: ServeType;
-    constructor({ score, playerId, target, failure, type, activeTraits }: ServeOpts);
-    toString(): string;
-}
-export {};
+import { InPlayEvent } from './in-play-event';
+export declare enum ServeTypeEnum {
+    OVERHAND_TOPSPIN = 0,
+    OVERHAND_FLOAT = 1,
+    JUMP_TOPSPIN = 2,
+    JUMP_FLOAT = 3
+}
+export type ServeType = ServeTypeEnum.OVERHAND_TOPSPIN | ServeTypeEnum.OVERHAND_FLOAT | ServeTypeEnum.JUMP_TOPSPIN | ServeTypeEnum.JUMP_FLOAT;
+export declare enum ServeFailureEnum {
+    NO_FAILURE = 0,
+    FAULT = 1,
+    MISS = 2,
+    NET = 3,
+    OUT_OF_BOUNDS = 4
+}
+export type ServeFailure = ServeFailureEnum.NO_FAILURE | ServeFailureEnum.FAULT | ServeFailureEnum.MISS | ServeFailureEnum.NET | ServeFailureEnum.OUT_OF_BOUNDS;
+export declare class Serve extends InPlayEvent<ServeFailure, ServeType> {
+    readonly failure: ServeFailure;
+    readonly type: ServeType;
+    static create(input: unknown): Serve;
+    private constructor();
+    toString(): string;
+}