volleyballsimtypes 0.0.175 → 0.0.177

package/dist/cjs/src/data/transformers/events.d.ts

@@ -0,0 +1,8 @@
+import { Block, LiberoReplacement, Reception, Serve, Set, Spike, Substitution } from '../../service';
+export declare function transformToBlock(event: any): Block;
+export declare function transformToLiberoReplacement(event: any): LiberoReplacement;
+export declare function transformToReception(event: any): Reception;
+export declare function transformToServe(event: any): Serve;
+export declare function transformToSet(event: any): Set;
+export declare function transformToSubstitution(event: any): Substitution;
+export declare function transformToSpike(event: any): Spike;

package/dist/cjs/src/data/transformers/events.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformToSpike = exports.transformToSubstitution = exports.transformToSet = exports.transformToServe = exports.transformToReception = exports.transformToLiberoReplacement = exports.transformToBlock = void 0;
+const service_1 = require("../../service");
+function transformToBlock(event) {
+    return new service_1.Block({
+        failure: event.failure,
+        type: event.type,
+        playerId: event.playerId,
+        target: event.target,
+        blockers: event.blockers,
+        score: event.score,
+        activeTraits: event.activeTraits
+    });
+}
+exports.transformToBlock = transformToBlock;
+function transformToLiberoReplacement(event) {
+    return new service_1.LiberoReplacement({
+        playerId: event.playerId,
+        libero: event.libero,
+        type: event.type
+    });
+}
+exports.transformToLiberoReplacement = transformToLiberoReplacement;
+function transformToReception(event) {
+    return new service_1.Reception({
+        failure: event.failure,
+        type: event.type,
+        playerId: event.playerId,
+        target: event.target,
+        score: event.score,
+        activeTraits: event.activeTraits
+    });
+}
+exports.transformToReception = transformToReception;
+function transformToServe(event) {
+    return new service_1.Serve({
+        failure: event.failure,
+        type: event.type,
+        playerId: event.playerId,
+        target: event.target,
+        score: event.score,
+        activeTraits: event.activeTraits
+    });
+}
+exports.transformToServe = transformToServe;
+function transformToSet(event) {
+    return new service_1.Set({
+        failure: event.failure,
+        type: event.type,
+        playerId: event.playerId,
+        target: event.target,
+        score: event.score,
+        activeTraits: event.activeTraits
+    });
+}
+exports.transformToSet = transformToSet;
+function transformToSubstitution(event) {
+    return new service_1.Substitution({
+        playerId: event.playerId,
+        playerOut: event.playerIdOut
+    });
+}
+exports.transformToSubstitution = transformToSubstitution;
+function transformToSpike(event) {
+    return new service_1.Spike({
+        failure: event.failure,
+        type: event.type,
+        playerId: event.playerId,
+        target: event.target,
+        score: event.score,
+        activeTraits: event.activeTraits
+    });
+}
+exports.transformToSpike = transformToSpike;

package/dist/cjs/src/data/transformers/rally.js

@@ -4,6 +4,7 @@ exports.transformFromRally = exports.transformToRally = void 0;
 const service_1 = require("../../service");
 const lz_string_1 = require("lz-string");
 const team_1 = require("./team");
+const events_1 = require("./events");
 function transformToAttributes(rally, setId) {
     const events = `[${rally.events.map((e) => e.toString()).join(',')}]`;
     return {
@@ -16,7 +17,36 @@ function transformToAttributes(rally, setId) {
 }
 exports.transformFromRally = transformToAttributes;
 function transformToObject(model) {
-    const events = JSON.parse((0, lz_string_1.decompressFromBase64)(model.events));
+    const decompressed = (0, lz_string_1.decompressFromBase64)(model.events);
+    const parsed = JSON.parse(decompressed);
+    const events = [];
+    parsed.forEach(event => {
+        switch (event.eventType) {
+            case 0:
+                events.push((0, events_1.transformToLiberoReplacement)(event));
+                break;
+            case 1:
+                events.push((0, events_1.transformToSubstitution)(event));
+                break;
+            case 2:
+                events.push((0, events_1.transformToServe)(event));
+                break;
+            case 3:
+                events.push((0, events_1.transformToReception)(event));
+                break;
+            case 4:
+                events.push((0, events_1.transformToSet)(event));
+                break;
+            case 5:
+                events.push((0, events_1.transformToSpike)(event));
+                break;
+            case 6:
+                events.push((0, events_1.transformToBlock)(event));
+                break;
+            default:
+                throw new Error('UNKNOWN_EVENT');
+        }
+    });
     return new service_1.Rally({
         id: model.rally_id,
         order: model.order,

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

@@ -0,0 +1,36 @@
+import { InPlayEvent } from './in-play-event';
+import { CourtTarget } from '../match';
+import { Trait } from '../player';
+export declare enum BlockFailureEnum {
+    NO_FAILURE = 0,
+    MISS = 1,
+    FAULT = 2,
+    OUT_OF_BOUNDS = 3,
+    WIPE = 4,
+    TOOL = 5
+}
+export type BlockFailure = BlockFailureEnum.NO_FAILURE | BlockFailureEnum.MISS | BlockFailureEnum.FAULT | BlockFailureEnum.OUT_OF_BOUNDS | BlockFailureEnum.WIPE | BlockFailureEnum.TOOL;
+export declare enum BlockTypeEnum {
+    NO_BLOCKER = 0,
+    SINGLE = 1,
+    DOUBLE = 2,
+    TRIPLE = 3
+}
+export type BlockType = BlockTypeEnum.NO_BLOCKER | BlockTypeEnum.SINGLE | BlockTypeEnum.DOUBLE | BlockTypeEnum.TRIPLE;
+interface BlockOpts {
+    readonly type: BlockType;
+    readonly failure: BlockFailure;
+    readonly blockers: string[];
+    readonly target: CourtTarget;
+    readonly score: number;
+    readonly activeTraits: Trait[];
+    readonly playerId: string;
+}
+export declare class Block extends InPlayEvent<BlockFailure, BlockType> {
+    readonly failure: BlockFailure;
+    readonly type: BlockType;
+    readonly blockers: string[];
+    constructor({ score, playerId, target, failure, type, blockers, activeTraits }: BlockOpts);
+    toString(): string;
+}
+export {};

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Block = exports.BlockTypeEnum = exports.BlockFailureEnum = void 0;
+const in_play_event_1 = require("./in-play-event");
+const rally_event_1 = require("./rally-event");
+var BlockFailureEnum;
+(function (BlockFailureEnum) {
+    BlockFailureEnum[BlockFailureEnum["NO_FAILURE"] = 0] = "NO_FAILURE";
+    BlockFailureEnum[BlockFailureEnum["MISS"] = 1] = "MISS";
+    BlockFailureEnum[BlockFailureEnum["FAULT"] = 2] = "FAULT";
+    BlockFailureEnum[BlockFailureEnum["OUT_OF_BOUNDS"] = 3] = "OUT_OF_BOUNDS";
+    BlockFailureEnum[BlockFailureEnum["WIPE"] = 4] = "WIPE";
+    BlockFailureEnum[BlockFailureEnum["TOOL"] = 5] = "TOOL";
+})(BlockFailureEnum = exports.BlockFailureEnum || (exports.BlockFailureEnum = {}));
+var BlockTypeEnum;
+(function (BlockTypeEnum) {
+    BlockTypeEnum[BlockTypeEnum["NO_BLOCKER"] = 0] = "NO_BLOCKER";
+    BlockTypeEnum[BlockTypeEnum["SINGLE"] = 1] = "SINGLE";
+    BlockTypeEnum[BlockTypeEnum["DOUBLE"] = 2] = "DOUBLE";
+    BlockTypeEnum[BlockTypeEnum["TRIPLE"] = 3] = "TRIPLE";
+})(BlockTypeEnum = exports.BlockTypeEnum || (exports.BlockTypeEnum = {}));
+const eventType = rally_event_1.EventTypeEnum.BLOCK;
+class Block extends in_play_event_1.InPlayEvent {
+    constructor({ score, playerId, target, failure, type, blockers, activeTraits }) {
+        super({ score, playerId, target, activeTraits, eventType });
+        this.type = type;
+        this.failure = failure;
+        this.blockers = blockers;
+    }
+    toString() {
+        const failure = `"failure":${this.failure}`;
+        const type = `"type":${this.type}`;
+        const blockers = `"blockers":[${this.blockers.map(b => `"${b}"`).join(',')}]`;
+        return `{${this._toString()},${failure},${type},${blockers}}`;
+    }
+}
+exports.Block = Block;

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

@@ -0,0 +1,7 @@
+import type { BlockFailure, BlockType } from './block';
+import type { ReceptionFailure, ReceptionType } from './reception';
+import type { ServeFailure, ServeType } from './serve';
+import type { SetFailure, SetType } from './set';
+import type { SpikeFailure, SpikeType } from './spike';
+export type EventSubType = BlockType | ReceptionType | ServeType | SetType | SpikeType;
+export type EventFailureType = BlockFailure | ReceptionFailure | ServeFailure | SetFailure | SpikeFailure;

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/src/service/event/in-play-event.d.ts

@@ -0,0 +1,17 @@
+import { CourtTarget } from '../match';
+import { RallyEvent, RallyEventOpts } from './rally-event';
+import { Trait } from '../player';
+export interface InPlayEventOpts extends RallyEventOpts {
+    readonly target: CourtTarget;
+    readonly score: number;
+    readonly activeTraits: Trait[];
+}
+export declare abstract class InPlayEvent<F, T> extends RallyEvent {
+    abstract failure: F;
+    abstract type: T;
+    readonly target: CourtTarget;
+    readonly score: number;
+    readonly activeTraits: Trait[];
+    protected constructor({ eventType, playerId, target, score, activeTraits }: InPlayEventOpts);
+    protected _toString(): string;
+}

package/dist/cjs/src/service/event/in-play-event.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InPlayEvent = void 0;
+const rally_event_1 = require("./rally-event");
+class InPlayEvent extends rally_event_1.RallyEvent {
+    constructor({ eventType, playerId, target, score, activeTraits }) {
+        super({ playerId, eventType });
+        this.target = target;
+        this.score = score;
+        this.activeTraits = activeTraits;
+    }
+    _toString() {
+        const score = `"score":${this.score}`;
+        const playerId = `"playerId":"${this.playerId}"`;
+        const target = `"target":${this.target}`;
+        const eventType = `"eventType":${this.eventType}`;
+        const traits = `"activeTraits":[${this.activeTraits.map(t => `"${t}"`).join(',')}]`;
+        return `${score},${playerId},${target},${eventType},${traits}`;
+    }
+}
+exports.InPlayEvent = InPlayEvent;

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

@@ -1,2 +1,10 @@
+export * from './block';
+export * from './event-types';
+export * from './in-play-event';
+export * from './libero-replacement';
 export * from './rally-event';
-export * from './events';
+export * from './reception';
+export * from './serve';
+export * from './set';
+export * from './spike';
+export * from './substitution';

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

@@ -14,5 +14,13 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./block"), exports);
+__exportStar(require("./event-types"), exports);
+__exportStar(require("./in-play-event"), exports);
+__exportStar(require("./libero-replacement"), exports);
 __exportStar(require("./rally-event"), exports);
-__exportStar(require("./events"), exports);
+__exportStar(require("./reception"), exports);
+__exportStar(require("./serve"), exports);
+__exportStar(require("./set"), exports);
+__exportStar(require("./spike"), exports);
+__exportStar(require("./substitution"), exports);

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

@@ -0,0 +1,18 @@
+import { RallyEvent } from './rally-event';
+export declare enum LiberoReplacementTypeEnum {
+    LIBERO_IN = 0,
+    LIBERO_OUT = 1
+}
+export type LiberoReplacementType = LiberoReplacementTypeEnum.LIBERO_IN | LiberoReplacementTypeEnum.LIBERO_OUT;
+interface LiberoReplacementOpts {
+    readonly playerId: string;
+    readonly libero: string;
+    readonly type: LiberoReplacementType;
+}
+export declare class LiberoReplacement extends RallyEvent {
+    readonly type: LiberoReplacementType;
+    readonly libero: string;
+    constructor({ playerId, type, libero }: LiberoReplacementOpts);
+    toString(): string;
+}
+export {};

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

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

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

@@ -1,11 +1,20 @@
-import { EventType } from './events';
+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 player: string;
+    readonly playerId: string;
     readonly eventType: EventType;
 }
 export declare abstract class RallyEvent {
-    readonly player: string;
+    readonly playerId: string;
     readonly eventType: EventType;
-    protected constructor({ eventType, player }: RallyEventOpts);
+    protected constructor({ eventType, playerId }: RallyEventOpts);
     abstract toString(): string;
 }

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

@@ -1,9 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RallyEvent = void 0;
+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, player }) {
-        this.player = player;
+    constructor({ eventType, playerId }) {
+        this.playerId = playerId;
         this.eventType = eventType;
     }
 }

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

@@ -0,0 +1,33 @@
+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 {};

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

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

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

@@ -0,0 +1,33 @@
+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 {};

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Serve = exports.ServeFailureEnum = exports.ServeTypeEnum = void 0;
+const rally_event_1 = require("./rally-event");
+const in_play_event_1 = require("./in-play-event");
+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 = exports.ServeTypeEnum || (exports.ServeTypeEnum = {}));
+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 = exports.ServeFailureEnum || (exports.ServeFailureEnum = {}));
+const eventType = rally_event_1.EventTypeEnum.SERVE;
+class Serve 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.Serve = Serve;

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

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

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Set = exports.SetFailureEnum = exports.SetTypeEnum = void 0;
+const rally_event_1 = require("./rally-event");
+const in_play_event_1 = require("./in-play-event");
+var SetTypeEnum;
+(function (SetTypeEnum) {
+    SetTypeEnum[SetTypeEnum["OVERHAND"] = 0] = "OVERHAND";
+    SetTypeEnum[SetTypeEnum["DUMP"] = 1] = "DUMP";
+})(SetTypeEnum = exports.SetTypeEnum || (exports.SetTypeEnum = {}));
+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 = exports.SetFailureEnum || (exports.SetFailureEnum = {}));
+const eventType = rally_event_1.EventTypeEnum.SET;
+class Set 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.Set = Set;

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

@@ -0,0 +1,35 @@
+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 {};

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Spike = exports.SpikeFailureEnum = exports.SpikeTypeEnum = void 0;
+const rally_event_1 = require("./rally-event");
+const in_play_event_1 = require("./in-play-event");
+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 = exports.SpikeTypeEnum || (exports.SpikeTypeEnum = {}));
+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 = exports.SpikeFailureEnum || (exports.SpikeFailureEnum = {}));
+const eventType = rally_event_1.EventTypeEnum.SPIKE;
+class Spike 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.Spike = Spike;