volleyballsimtypes 0.0.175 → 0.0.176

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Substitution = void 0;
+const rally_event_1 = require("./rally-event");
+const eventType = rally_event_1.EventTypeEnum.SUBSTITUTION;
+class Substitution extends rally_event_1.RallyEvent {
+    constructor({ playerOut, playerId }) {
+        super({ eventType, playerId });
+        this.playerOut = playerOut;
+    }
+    toString() {
+        const playerId = `"playerId":"${this.playerId}"`;
+        const playerOut = `"playerOut":"${this.playerOut}"`;
+        const eventType = `"eventType":${this.eventType}`;
+        return `{${playerId},${playerOut},${eventType}}`;
+    }
+}
+exports.Substitution = Substitution;

package/dist/esm/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/esm/src/data/transformers/events.js

@@ -0,0 +1,65 @@
+import { Block, LiberoReplacement, Reception, Serve, Set, Spike, Substitution } from '../../service';
+export function transformToBlock(event) {
+    return new Block({
+        failure: event.failure,
+        type: event.type,
+        playerId: event.playerId,
+        target: event.target,
+        blockers: event.blockers,
+        score: event.score,
+        activeTraits: event.activeTraits
+    });
+}
+export function transformToLiberoReplacement(event) {
+    return new LiberoReplacement({
+        playerId: event.playerId,
+        libero: event.libero,
+        type: event.type
+    });
+}
+export function transformToReception(event) {
+    return new Reception({
+        failure: event.failure,
+        type: event.type,
+        playerId: event.playerId,
+        target: event.target,
+        score: event.score,
+        activeTraits: event.activeTraits
+    });
+}
+export function transformToServe(event) {
+    return new Serve({
+        failure: event.failure,
+        type: event.type,
+        playerId: event.playerId,
+        target: event.target,
+        score: event.score,
+        activeTraits: event.activeTraits
+    });
+}
+export function transformToSet(event) {
+    return new Set({
+        failure: event.failure,
+        type: event.type,
+        playerId: event.playerId,
+        target: event.target,
+        score: event.score,
+        activeTraits: event.activeTraits
+    });
+}
+export function transformToSubstitution(event) {
+    return new Substitution({
+        playerId: event.playerId,
+        playerOut: event.playerIdOut
+    });
+}
+export function transformToSpike(event) {
+    return new Spike({
+        failure: event.failure,
+        type: event.type,
+        playerId: event.playerId,
+        target: event.target,
+        score: event.score,
+        activeTraits: event.activeTraits
+    });
+}

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

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

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

@@ -0,0 +1,33 @@
+import { InPlayEvent } from './in-play-event';
+import { EventTypeEnum } from './rally-event';
+export 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 || (BlockFailureEnum = {}));
+export 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 || (BlockTypeEnum = {}));
+const eventType = EventTypeEnum.BLOCK;
+export class Block extends 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}}`;
+    }
+}

package/dist/esm/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/esm/src/service/event/in-play-event.js

@@ -0,0 +1,17 @@
+import { RallyEvent } from './rally-event';
+export class InPlayEvent extends 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}`;
+    }
+}

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

@@ -1,2 +1,9 @@
+export * from './block';
+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/esm/src/service/event/index.js

@@ -1,2 +1,9 @@
+export * from './block';
+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/esm/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/esm/src/service/event/libero-replacement.js

@@ -0,0 +1,21 @@
+import { EventTypeEnum, RallyEvent } from './rally-event';
+export var LiberoReplacementTypeEnum;
+(function (LiberoReplacementTypeEnum) {
+    LiberoReplacementTypeEnum[LiberoReplacementTypeEnum["LIBERO_IN"] = 0] = "LIBERO_IN";
+    LiberoReplacementTypeEnum[LiberoReplacementTypeEnum["LIBERO_OUT"] = 1] = "LIBERO_OUT";
+})(LiberoReplacementTypeEnum || (LiberoReplacementTypeEnum = {}));
+const eventType = EventTypeEnum.LIBERO_REPLACEMENT;
+export class LiberoReplacement extends 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}}`;
+    }
+}

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

@@ -1,6 +1,16 @@
+export 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 || (EventTypeEnum = {}));
 export class RallyEvent {
-    constructor({ eventType, player }) {
-        this.player = player;
+    constructor({ eventType, playerId }) {
+        this.playerId = playerId;
         this.eventType = eventType;
     }
 }

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

@@ -0,0 +1,30 @@
+import { EventTypeEnum } from './rally-event';
+import { InPlayEvent } from './in-play-event';
+export 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 || (ReceptionTypeEnum = {}));
+export 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 || (ReceptionFailureEnum = {}));
+const eventType = EventTypeEnum.RECEPTION;
+export class Reception 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}}`;
+    }
+}

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

@@ -0,0 +1,30 @@
+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}}`;
+    }
+}

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

@@ -0,0 +1,28 @@
+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}}`;
+    }
+}

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

@@ -0,0 +1,32 @@
+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}}`;
+    }
+}

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

@@ -0,0 +1,11 @@
+import { RallyEvent } from './rally-event';
+interface SubstitutionOpts {
+    readonly playerOut: string;
+    readonly playerId: string;
+}
+export declare class Substitution extends RallyEvent {
+    readonly playerOut: string;
+    constructor({ playerOut, playerId }: SubstitutionOpts);
+    toString(): string;
+}
+export {};

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

@@ -0,0 +1,14 @@
+import { EventTypeEnum, RallyEvent } from './rally-event';
+const eventType = EventTypeEnum.SUBSTITUTION;
+export class Substitution extends RallyEvent {
+    constructor({ playerOut, playerId }) {
+        super({ eventType, playerId });
+        this.playerOut = playerOut;
+    }
+    toString() {
+        const playerId = `"playerId":"${this.playerId}"`;
+        const playerOut = `"playerOut":"${this.playerOut}"`;
+        const eventType = `"eventType":${this.eventType}`;
+        return `{${playerId},${playerOut},${eventType}}`;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "volleyballsimtypes",
-  "version": "0.0.175",
+  "version": "0.0.176",
   "description": "vbsim types",
   "main": "./dist/cjs/src/index.js",
   "module": "./dist/esm/src/index.js",