volleyballsimtypes 0.0.174 → 0.0.176

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/dist/esm/src/service/match/match-set.d.ts

@@ -1,6 +1,5 @@
 import { PlayerPosition, Rally } from './rally';
 import { MatchTeam } from './match-team';
-import { Player } from '../player';
 declare enum ScoreThreshold {
     SET = 25,
     TIE_BREAK = 15
@@ -21,7 +20,8 @@ export interface EventStat {
     error: number;
 }
 export interface SetStatistics {
-    player: Player;
+    readonly playerId: string;
+    order: number;
     ace: number;
     attempts: number;
     contacts: number;
@@ -34,6 +34,7 @@ export interface SetStatistics {
     kills: number;
     killBlocks: number;
     assists: number;
+    setsPlayed: number;
 }
 export declare class MatchSet {
     readonly id: string;
@@ -52,7 +53,7 @@ export declare class MatchSet {
     increaseScore(team: MatchTeam): void;
     addRally(rally: Rally): void;
     /**
-     * Has a team reached at least 25 points and is the score difference between both teams at least 2?
+     * Has a team reached at least 25 points, and is the score difference between both teams at least 2?
      * @returns boolean
      */
     isOver(): boolean;

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

@@ -37,7 +37,7 @@ export class MatchSet {
         this.rallies.push(rally);
     }
     /**
-     * Has a team reached at least 25 points and is the score difference between both teams at least 2?
+     * Has a team reached at least 25 points, and is the score difference between both teams at least 2?
      * @returns boolean
      */
     isOver() {

package/dist/esm/src/service/player/player.d.ts

@@ -4,6 +4,7 @@ import { Country } from '../country';
 import { Rarity } from './rarity';
 import { Stats } from './stats';
 import { Role } from './role';
+import { SetStatistics } from '../match';
 export declare class Stat {
     readonly name: Stats;
     readonly value: number;
@@ -21,6 +22,7 @@ interface PlayerParams {
     readonly roles: Role[];
     readonly traits: Trait[];
     readonly rarity: Rarity;
+    readonly gameStats?: SetStatistics[];
 }
 export declare class Name {
     readonly first: string;
@@ -40,7 +42,8 @@ export declare class Player {
     readonly traits: Trait[];
     readonly generalStats: Stat[];
     readonly rarity: Rarity;
-    constructor({ id, name, country, stats, roles, traits, rarity }: PlayerParams);
+    readonly gameStats?: SetStatistics[];
+    constructor({ id, name, country, stats, roles, traits, rarity, gameStats }: PlayerParams);
     static sortPlayers(roles: Role[]): (p1: Player, p2: Player) => number;
     static compareStats(p1: Player, p2: Player): number;
     toString(): string;

package/dist/esm/src/service/player/player.js

@@ -20,7 +20,7 @@ export class Name {
     }
 }
 export class Player {
-    constructor({ id, name, country, stats, roles, traits, rarity }) {
+    constructor({ id, name, country, stats, roles, traits, rarity, gameStats }) {
         validateUUID(id);
         this.id = id;
         this.name = name;
@@ -29,6 +29,7 @@ export class Player {
         this.roles = roles;
         this.traits = traits;
         this.rarity = rarity;
+        this.gameStats = gameStats;
         this.generalStats = Object.values(StatsEnum).map((stat) => ({
             name: stat,
             value: calculateStatScore(stats, stat)

package/package.json

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

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

@@ -1,93 +0,0 @@
-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 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;
-export declare enum LiberoReplacementTypeEnum {
-    LIBERO_IN = 0,
-    LIBERO_OUT = 1
-}
-export type LiberoReplacementType = LiberoReplacementTypeEnum.LIBERO_IN | LiberoReplacementTypeEnum.LIBERO_OUT;
-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 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 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 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 type EventSubType = BlockType | ReceptionType | ServeType | SetType | SpikeType;
-export type EventFailureType = BlockFailure | ReceptionFailure | ServeFailure | SetFailure | SpikeFailure;