volleyballsimtypes 0.0.217 → 0.0.358

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

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { TraitEnum } from '../../player';
+const blockTypeValues = [0, 1, 2, 3];
+const blockFailureValues = [0, 1, 2, 3, 4, 5];
+const courtTargetValues = Array.from({ length: 13 }, (_, i) => i);
+export const BlockInputSchema = z.object({
+    playerId: z.uuid(),
+    score: z.number().finite(),
+    target: z.number().int().refine((v) => courtTargetValues.includes(v), { message: 'INVALID_COURT_TARGET' }),
+    activeTraits: z.array(z.enum(Object.values(TraitEnum))),
+    failure: z.number().int().refine((v) => blockFailureValues.includes(v), { message: 'INVALID_BLOCK_FAILURE' }),
+    type: z.number().int().refine((v) => blockTypeValues.includes(v), { message: 'INVALID_BLOCK_TYPE' }),
+    blockers: z.array(z.uuid())
+});

package/dist/esm/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/esm/src/service/event/schemas/libero-replacement.z.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+const liberoReplacementTypeValues = [0, 1];
+export const LiberoReplacementInputSchema = z.object({
+    playerId: z.uuid(),
+    libero: z.uuid(),
+    type: 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/esm/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/esm/src/service/event/schemas/reception.z.js

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { TraitEnum } from '../../player';
+const receptionTypeValues = [0, 1, 2, 3];
+const receptionFailureValues = [0, 1, 2, 3, 4];
+const courtTargetValues = Array.from({ length: 13 }, (_, i) => i);
+export const ReceptionInputSchema = z.object({
+    playerId: z.uuid(),
+    score: z.number().finite(),
+    target: z.number().int().refine((v) => courtTargetValues.includes(v), { message: 'INVALID_COURT_TARGET' }),
+    activeTraits: z.array(z.enum(Object.values(TraitEnum))),
+    failure: z.number().int().refine((v) => receptionFailureValues.includes(v), { message: 'INVALID_RECEPTION_FAILURE' }),
+    type: z.number().int().refine((v) => receptionTypeValues.includes(v), { message: 'INVALID_RECEPTION_TYPE' })
+});

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

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { TraitEnum } from '../../player';
+const serveTypeValues = [0, 1, 2, 3];
+const serveFailureValues = [0, 1, 2, 3, 4];
+const courtTargetValues = Array.from({ length: 13 }, (_, i) => i);
+export const ServeInputSchema = z.object({
+    playerId: z.uuid(),
+    score: z.number().finite(),
+    target: z.number().int().refine((v) => courtTargetValues.includes(v), { message: 'INVALID_COURT_TARGET' }),
+    activeTraits: z.array(z.enum(Object.values(TraitEnum))),
+    failure: z.number().int().refine((v) => serveFailureValues.includes(v), { message: 'INVALID_SERVE_FAILURE' }),
+    type: z.number().int().refine((v) => serveTypeValues.includes(v), { message: 'INVALID_SERVE_TYPE' })
+});

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

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { TraitEnum } from '../../player';
+const setTypeValues = [0, 1];
+const setFailureValues = [0, 1, 2, 3, 4];
+const courtTargetValues = Array.from({ length: 13 }, (_, i) => i);
+export const SetInputSchema = z.object({
+    playerId: z.uuid(),
+    score: z.number().finite(),
+    target: z.number().int().refine((v) => courtTargetValues.includes(v), { message: 'INVALID_COURT_TARGET' }),
+    activeTraits: z.array(z.enum(Object.values(TraitEnum))),
+    failure: z.number().int().refine((v) => setFailureValues.includes(v), { message: 'INVALID_SET_FAILURE' }),
+    type: z.number().int().refine((v) => setTypeValues.includes(v), { message: 'INVALID_SET_TYPE' })
+});

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

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

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

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+export const SubstitutionInputSchema = z.object({
+    playerId: z.uuid(),
+    playerOut: 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/esm/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;
+}

package/dist/esm/src/service/event/serve.js

@@ -1,30 +1,43 @@
-import { EventTypeEnum } from './rally-event';
-import { InPlayEvent } from './in-play-event';
-export var ServeTypeEnum;
-(function (ServeTypeEnum) {
-    ServeTypeEnum[ServeTypeEnum["OVERHAND_TOPSPIN"] = 0] = "OVERHAND_TOPSPIN";
-    ServeTypeEnum[ServeTypeEnum["OVERHAND_FLOAT"] = 1] = "OVERHAND_FLOAT";
-    ServeTypeEnum[ServeTypeEnum["JUMP_TOPSPIN"] = 2] = "JUMP_TOPSPIN";
-    ServeTypeEnum[ServeTypeEnum["JUMP_FLOAT"] = 3] = "JUMP_FLOAT";
-})(ServeTypeEnum || (ServeTypeEnum = {}));
-export var ServeFailureEnum;
-(function (ServeFailureEnum) {
-    ServeFailureEnum[ServeFailureEnum["NO_FAILURE"] = 0] = "NO_FAILURE";
-    ServeFailureEnum[ServeFailureEnum["FAULT"] = 1] = "FAULT";
-    ServeFailureEnum[ServeFailureEnum["MISS"] = 2] = "MISS";
-    ServeFailureEnum[ServeFailureEnum["NET"] = 3] = "NET";
-    ServeFailureEnum[ServeFailureEnum["OUT_OF_BOUNDS"] = 4] = "OUT_OF_BOUNDS";
-})(ServeFailureEnum || (ServeFailureEnum = {}));
-const eventType = EventTypeEnum.SERVE;
-export class Serve extends 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}}`;
-    }
-}
+import { EventTypeEnum } from './rally-event';
+import { InPlayEvent } from './in-play-event';
+import { ServeInputSchema } from './schemas/serve.z';
+export var ServeTypeEnum;
+(function (ServeTypeEnum) {
+    ServeTypeEnum[ServeTypeEnum["OVERHAND_TOPSPIN"] = 0] = "OVERHAND_TOPSPIN";
+    ServeTypeEnum[ServeTypeEnum["OVERHAND_FLOAT"] = 1] = "OVERHAND_FLOAT";
+    ServeTypeEnum[ServeTypeEnum["JUMP_TOPSPIN"] = 2] = "JUMP_TOPSPIN";
+    ServeTypeEnum[ServeTypeEnum["JUMP_FLOAT"] = 3] = "JUMP_FLOAT";
+})(ServeTypeEnum || (ServeTypeEnum = {}));
+export var ServeFailureEnum;
+(function (ServeFailureEnum) {
+    ServeFailureEnum[ServeFailureEnum["NO_FAILURE"] = 0] = "NO_FAILURE";
+    ServeFailureEnum[ServeFailureEnum["FAULT"] = 1] = "FAULT";
+    ServeFailureEnum[ServeFailureEnum["MISS"] = 2] = "MISS";
+    ServeFailureEnum[ServeFailureEnum["NET"] = 3] = "NET";
+    ServeFailureEnum[ServeFailureEnum["OUT_OF_BOUNDS"] = 4] = "OUT_OF_BOUNDS";
+})(ServeFailureEnum || (ServeFailureEnum = {}));
+const eventType = EventTypeEnum.SERVE;
+export class Serve extends InPlayEvent {
+    static create(input) {
+        const result = ServeInputSchema.safeParse(input);
+        if (!result.success) {
+            throw new Error(`INVALID_SERVE: ${result.error.message}. RECEIVED=${(() => { try {
+                return JSON.stringify(input);
+            }
+            catch {
+                return String(input);
+            } })()}`);
+        }
+        return new Serve(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}}`;
+    }
+}

package/dist/esm/src/service/event/set.d.ts

@@ -1,31 +1,21 @@
-import { CourtTarget } from '../match';
-import { Trait } from '../player';
-import { InPlayEvent } from './in-play-event';
-export declare enum SetTypeEnum {
-    OVERHAND = 0,
-    DUMP = 1
-}
-export type SetType = SetTypeEnum.OVERHAND | SetTypeEnum.DUMP;
-export declare enum SetFailureEnum {
-    NO_FAILURE = 0,
-    FAULT = 1,
-    MISS = 2,
-    BAD_PASS = 3,
-    OUT_OF_BOUNDS = 4
-}
-export type SetFailure = SetFailureEnum.NO_FAILURE | SetFailureEnum.FAULT | SetFailureEnum.MISS | SetFailureEnum.BAD_PASS | SetFailureEnum.OUT_OF_BOUNDS;
-interface SetOpts {
-    readonly type: SetType;
-    readonly failure: SetFailure;
-    readonly target: CourtTarget;
-    readonly score: number;
-    readonly activeTraits: Trait[];
-    readonly playerId: string;
-}
-export declare class Set extends InPlayEvent<SetFailure, SetType> {
-    readonly failure: SetFailure;
-    readonly type: SetType;
-    constructor({ score, playerId, target, failure, type, activeTraits }: SetOpts);
-    toString(): string;
-}
-export {};
+import { InPlayEvent } from './in-play-event';
+export declare enum SetTypeEnum {
+    OVERHAND = 0,
+    DUMP = 1
+}
+export type SetType = SetTypeEnum.OVERHAND | SetTypeEnum.DUMP;
+export declare enum SetFailureEnum {
+    NO_FAILURE = 0,
+    FAULT = 1,
+    MISS = 2,
+    BAD_PASS = 3,
+    OUT_OF_BOUNDS = 4
+}
+export type SetFailure = SetFailureEnum.NO_FAILURE | SetFailureEnum.FAULT | SetFailureEnum.MISS | SetFailureEnum.BAD_PASS | SetFailureEnum.OUT_OF_BOUNDS;
+export declare class Set extends InPlayEvent<SetFailure, SetType> {
+    readonly failure: SetFailure;
+    readonly type: SetType;
+    static create(input: unknown): Set;
+    private constructor();
+    toString(): string;
+}

package/dist/esm/src/service/event/set.js

@@ -1,28 +1,41 @@
-import { EventTypeEnum } from './rally-event';
-import { InPlayEvent } from './in-play-event';
-export var SetTypeEnum;
-(function (SetTypeEnum) {
-    SetTypeEnum[SetTypeEnum["OVERHAND"] = 0] = "OVERHAND";
-    SetTypeEnum[SetTypeEnum["DUMP"] = 1] = "DUMP";
-})(SetTypeEnum || (SetTypeEnum = {}));
-export var SetFailureEnum;
-(function (SetFailureEnum) {
-    SetFailureEnum[SetFailureEnum["NO_FAILURE"] = 0] = "NO_FAILURE";
-    SetFailureEnum[SetFailureEnum["FAULT"] = 1] = "FAULT";
-    SetFailureEnum[SetFailureEnum["MISS"] = 2] = "MISS";
-    SetFailureEnum[SetFailureEnum["BAD_PASS"] = 3] = "BAD_PASS";
-    SetFailureEnum[SetFailureEnum["OUT_OF_BOUNDS"] = 4] = "OUT_OF_BOUNDS";
-})(SetFailureEnum || (SetFailureEnum = {}));
-const eventType = EventTypeEnum.SET;
-export class Set extends 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}}`;
-    }
-}
+import { EventTypeEnum } from './rally-event';
+import { InPlayEvent } from './in-play-event';
+import { SetInputSchema } from './schemas/set.z';
+export var SetTypeEnum;
+(function (SetTypeEnum) {
+    SetTypeEnum[SetTypeEnum["OVERHAND"] = 0] = "OVERHAND";
+    SetTypeEnum[SetTypeEnum["DUMP"] = 1] = "DUMP";
+})(SetTypeEnum || (SetTypeEnum = {}));
+export var SetFailureEnum;
+(function (SetFailureEnum) {
+    SetFailureEnum[SetFailureEnum["NO_FAILURE"] = 0] = "NO_FAILURE";
+    SetFailureEnum[SetFailureEnum["FAULT"] = 1] = "FAULT";
+    SetFailureEnum[SetFailureEnum["MISS"] = 2] = "MISS";
+    SetFailureEnum[SetFailureEnum["BAD_PASS"] = 3] = "BAD_PASS";
+    SetFailureEnum[SetFailureEnum["OUT_OF_BOUNDS"] = 4] = "OUT_OF_BOUNDS";
+})(SetFailureEnum || (SetFailureEnum = {}));
+const eventType = EventTypeEnum.SET;
+export class Set extends InPlayEvent {
+    static create(input) {
+        const result = SetInputSchema.safeParse(input);
+        if (!result.success) {
+            throw new Error(`INVALID_SET: ${result.error.message}. RECEIVED=${(() => { try {
+                return JSON.stringify(input);
+            }
+            catch {
+                return String(input);
+            } })()}`);
+        }
+        return new Set(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}}`;
+    }
+}

package/dist/esm/src/service/event/spike.d.ts

@@ -1,35 +1,25 @@
-import { CourtTarget } from '../match';
-import { Trait } from '../player';
-import { InPlayEvent } from './in-play-event';
-export declare enum SpikeTypeEnum {
-    CROSS_SHOT = 0,
-    LINE_SHOT = 1,
-    REVERSE_CROSS = 2,
-    TIP = 3,
-    DOWN_BALL = 4,
-    OVERHAND = 5
-}
-export type SpikeType = SpikeTypeEnum.CROSS_SHOT | SpikeTypeEnum.LINE_SHOT | SpikeTypeEnum.REVERSE_CROSS | SpikeTypeEnum.TIP | SpikeTypeEnum.DOWN_BALL | SpikeTypeEnum.OVERHAND;
-export declare enum SpikeFailureEnum {
-    NO_FAILURE = 0,
-    FAULT = 1,
-    MISS = 2,
-    OUT_OF_BOUNDS = 3,
-    NET = 4
-}
-export type SpikeFailure = SpikeFailureEnum.NO_FAILURE | SpikeFailureEnum.FAULT | SpikeFailureEnum.MISS | SpikeFailureEnum.OUT_OF_BOUNDS | SpikeFailureEnum.NET;
-interface SpikeOpts {
-    readonly type: SpikeType;
-    readonly failure: SpikeFailure;
-    readonly target: CourtTarget;
-    readonly score: number;
-    readonly activeTraits: Trait[];
-    readonly playerId: string;
-}
-export declare class Spike extends InPlayEvent<SpikeFailure, SpikeType> {
-    readonly failure: SpikeFailure;
-    readonly type: SpikeType;
-    constructor({ score, playerId, target, failure, type, activeTraits }: SpikeOpts);
-    toString(): string;
-}
-export {};
+import { InPlayEvent } from './in-play-event';
+export declare enum SpikeTypeEnum {
+    CROSS_SHOT = 0,
+    LINE_SHOT = 1,
+    REVERSE_CROSS = 2,
+    TIP = 3,
+    DOWN_BALL = 4,
+    OVERHAND = 5
+}
+export type SpikeType = SpikeTypeEnum.CROSS_SHOT | SpikeTypeEnum.LINE_SHOT | SpikeTypeEnum.REVERSE_CROSS | SpikeTypeEnum.TIP | SpikeTypeEnum.DOWN_BALL | SpikeTypeEnum.OVERHAND;
+export declare enum SpikeFailureEnum {
+    NO_FAILURE = 0,
+    FAULT = 1,
+    MISS = 2,
+    OUT_OF_BOUNDS = 3,
+    NET = 4
+}
+export type SpikeFailure = SpikeFailureEnum.NO_FAILURE | SpikeFailureEnum.FAULT | SpikeFailureEnum.MISS | SpikeFailureEnum.OUT_OF_BOUNDS | SpikeFailureEnum.NET;
+export declare class Spike extends InPlayEvent<SpikeFailure, SpikeType> {
+    readonly failure: SpikeFailure;
+    readonly type: SpikeType;
+    static create(input: unknown): Spike;
+    private constructor();
+    toString(): string;
+}

package/dist/esm/src/service/event/spike.js

@@ -1,32 +1,45 @@
-import { EventTypeEnum } from './rally-event';
-import { InPlayEvent } from './in-play-event';
-export var SpikeTypeEnum;
-(function (SpikeTypeEnum) {
-    SpikeTypeEnum[SpikeTypeEnum["CROSS_SHOT"] = 0] = "CROSS_SHOT";
-    SpikeTypeEnum[SpikeTypeEnum["LINE_SHOT"] = 1] = "LINE_SHOT";
-    SpikeTypeEnum[SpikeTypeEnum["REVERSE_CROSS"] = 2] = "REVERSE_CROSS";
-    SpikeTypeEnum[SpikeTypeEnum["TIP"] = 3] = "TIP";
-    SpikeTypeEnum[SpikeTypeEnum["DOWN_BALL"] = 4] = "DOWN_BALL";
-    SpikeTypeEnum[SpikeTypeEnum["OVERHAND"] = 5] = "OVERHAND";
-})(SpikeTypeEnum || (SpikeTypeEnum = {}));
-export var SpikeFailureEnum;
-(function (SpikeFailureEnum) {
-    SpikeFailureEnum[SpikeFailureEnum["NO_FAILURE"] = 0] = "NO_FAILURE";
-    SpikeFailureEnum[SpikeFailureEnum["FAULT"] = 1] = "FAULT";
-    SpikeFailureEnum[SpikeFailureEnum["MISS"] = 2] = "MISS";
-    SpikeFailureEnum[SpikeFailureEnum["OUT_OF_BOUNDS"] = 3] = "OUT_OF_BOUNDS";
-    SpikeFailureEnum[SpikeFailureEnum["NET"] = 4] = "NET";
-})(SpikeFailureEnum || (SpikeFailureEnum = {}));
-const eventType = EventTypeEnum.SPIKE;
-export class Spike extends 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}}`;
-    }
-}
+import { EventTypeEnum } from './rally-event';
+import { InPlayEvent } from './in-play-event';
+import { SpikeInputSchema } from './schemas/spike.z';
+export var SpikeTypeEnum;
+(function (SpikeTypeEnum) {
+    SpikeTypeEnum[SpikeTypeEnum["CROSS_SHOT"] = 0] = "CROSS_SHOT";
+    SpikeTypeEnum[SpikeTypeEnum["LINE_SHOT"] = 1] = "LINE_SHOT";
+    SpikeTypeEnum[SpikeTypeEnum["REVERSE_CROSS"] = 2] = "REVERSE_CROSS";
+    SpikeTypeEnum[SpikeTypeEnum["TIP"] = 3] = "TIP";
+    SpikeTypeEnum[SpikeTypeEnum["DOWN_BALL"] = 4] = "DOWN_BALL";
+    SpikeTypeEnum[SpikeTypeEnum["OVERHAND"] = 5] = "OVERHAND";
+})(SpikeTypeEnum || (SpikeTypeEnum = {}));
+export var SpikeFailureEnum;
+(function (SpikeFailureEnum) {
+    SpikeFailureEnum[SpikeFailureEnum["NO_FAILURE"] = 0] = "NO_FAILURE";
+    SpikeFailureEnum[SpikeFailureEnum["FAULT"] = 1] = "FAULT";
+    SpikeFailureEnum[SpikeFailureEnum["MISS"] = 2] = "MISS";
+    SpikeFailureEnum[SpikeFailureEnum["OUT_OF_BOUNDS"] = 3] = "OUT_OF_BOUNDS";
+    SpikeFailureEnum[SpikeFailureEnum["NET"] = 4] = "NET";
+})(SpikeFailureEnum || (SpikeFailureEnum = {}));
+const eventType = EventTypeEnum.SPIKE;
+export class Spike extends InPlayEvent {
+    static create(input) {
+        const result = SpikeInputSchema.safeParse(input);
+        if (!result.success) {
+            throw new Error(`INVALID_SPIKE: ${result.error.message}. RECEIVED=${(() => { try {
+                return JSON.stringify(input);
+            }
+            catch {
+                return String(input);
+            } })()}`);
+        }
+        return new Spike(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}}`;
+    }
+}