volleyballsimtypes 0.0.74 → 0.0.76

package/dist/esm/src/service/coach/formation.d.ts

@@ -9,12 +9,12 @@ interface PositionRole {
     readonly [CourtPosition.RIGHT_BACK]: Role[];
 }
 export interface SubPriority {
-    readonly [Role.MIDDLE_BLOCKER]: number;
-    readonly [Role.LIBERO]: number;
-    readonly [Role.DEFENSIVE_SPECIALIST]: number;
-    readonly [Role.OUTSIDE_HITTER]: number;
-    readonly [Role.OPPOSITE_HITTER]: number;
-    readonly [Role.SETTER]: number;
+    readonly 'Middle Blocker': number;
+    readonly 'Outside Hitter': number;
+    readonly 'Opposite Hitter': number;
+    readonly 'Defensive Specialist': number;
+    readonly Setter: number;
+    readonly Libero: number;
 }
 export declare class Formation {
     static readonly '5-1': Formation;

package/dist/esm/src/service/coach/formation.js

@@ -80,7 +80,7 @@ Formation['4-2'] = new Formation({
         'Outside Hitter': 10,
         'Opposite Hitter': 100,
         'Defensive Specialist': 1000,
-        [Role.SETTER]: 10000,
+        Setter: 10000,
         Libero: 100000
     }
 });

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

@@ -1,3 +1,2 @@
-import { Coach } from './coach';
-import { Formation, SubPriority } from './formation';
-export { Coach, Formation, SubPriority };
+export * from './coach';
+export * from './formation';

package/dist/esm/src/service/coach/index.js

@@ -1,3 +1,2 @@
-import { Coach } from './coach';
-import { Formation } from './formation';
-export { Coach, Formation };
+export * from './coach';
+export * from './formation';

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

@@ -1,8 +1,7 @@
-import { Standing } from './standing';
-import { Season } from './season';
-import { League } from './league';
-import { Iteration } from './iteration';
-import { Tournament } from './tournament';
-import { TournamentMatch } from './tournament-match';
-import { Stage } from './stage';
-export { TournamentMatch, Stage, Tournament, Season, Standing, League, Iteration, };
+export * from './standing';
+export * from './season';
+export * from './league';
+export * from './iteration';
+export * from './tournament';
+export * from './tournament-match';
+export * from './stage';

package/dist/esm/src/service/competition/index.js

@@ -1,8 +1,7 @@
-import { Standing } from './standing';
-import { Season } from './season';
-import { League } from './league';
-import { Iteration } from './iteration';
-import { Tournament } from './tournament';
-import { TournamentMatch } from './tournament-match';
-import { Stage } from './stage';
-export { TournamentMatch, Stage, Tournament, Season, Standing, League, Iteration, };
+export * from './standing';
+export * from './season';
+export * from './league';
+export * from './iteration';
+export * from './tournament';
+export * from './tournament-match';
+export * from './stage';

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

@@ -1,2 +1 @@
-import { Country } from './country';
-export { Country };
+export * from './country';

package/dist/esm/src/service/country/index.js

@@ -1,2 +1 @@
-import { Country } from './country';
-export { Country };
+export * from './country';

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

@@ -1,3 +1,2 @@
-import { Draft } from './draft';
-import { DraftPick } from './draft-pick';
-export { Draft, DraftPick };
+export * from './draft';
+export * from './draft-pick';

package/dist/esm/src/service/draft/index.js

@@ -1,3 +1,2 @@
-import { Draft } from './draft';
-import { DraftPick } from './draft-pick';
-export { Draft, DraftPick };
+export * from './draft';
+export * from './draft-pick';

package/dist/esm/src/service/event/__stubs__/index.js

@@ -1,7 +1,7 @@
-import { Serve, ServeFailure, ServeType } from '../serve';
+import { Serve, ServeFailureEnum, ServeTypeEnum } from '../serve';
 import { player } from '../../player/__stubs__';
-import { CourtTarget } from '../../match';
-import { EventType } from '../rally-event';
+import { CourtTargetEnum } from '../../match';
+import { EventTypeEnum } from '../rally-event';
 import { Score } from '../score';
 import { team } from '../../team/__stubs__';
 export const serve = new Serve({
@@ -9,16 +9,16 @@ export const serve = new Serve({
     order: 0,
     id: 'e92f4abb-66f4-4b6c-a602-258404d04484',
     player: player,
-    target: CourtTarget.OPPONENT_RIGHT_BACK,
-    eventType: EventType.SERVE,
-    type: ServeType.JUMP_FLOAT,
-    failure: ServeFailure.NO_FAILURE,
+    target: CourtTargetEnum.OPPONENT_RIGHT_BACK,
+    eventType: EventTypeEnum.SERVE,
+    type: ServeTypeEnum.JUMP_FLOAT,
+    failure: ServeFailureEnum.NO_FAILURE,
     modifier: 1
 });
 export const score = new Score({
     id: 'e92f4abb-66f4-4b6c-a602-258404d04484',
     order: 0,
-    eventType: EventType.SCORE,
+    eventType: EventTypeEnum.SCORE,
     player,
     team
 });

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

@@ -1,6 +1,6 @@
 import { InPlayEvent, InPlayEventOpts } from './in-play-event';
 import { Player } from '../player';
-export declare enum BlockFailure {
+export declare enum BlockFailureEnum {
     NO_FAILURE = 0,
     FAULT = 1,
     MISS = 2,
@@ -8,20 +8,20 @@ export declare enum BlockFailure {
     WIPE = 4,
     TOOL = 5
 }
-export declare enum BlockType {
+export declare enum BlockTypeEnum {
     NO_BLOCKER = 0,
     SINGLE = 1,
     DOUBLE = 2,
     TRIPLE = 3
 }
 interface BlockOpts extends InPlayEventOpts {
-    readonly type: BlockType;
-    readonly failure: BlockFailure;
+    readonly type: BlockTypeEnum;
+    readonly failure: BlockFailureEnum;
     readonly blockers: Player[];
 }
 export declare class Block extends InPlayEvent {
-    readonly failure: BlockFailure;
-    readonly type: BlockType;
+    readonly failure: BlockFailureEnum;
+    readonly type: BlockTypeEnum;
     readonly blockers: Player[];
     constructor({ id, order, score, player, target, failure, type, modifier, eventType, blockers }: BlockOpts);
     static getScore(blockers: Player[], modifier: number): number;

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

@@ -1,20 +1,20 @@
 import { InPlayEvent } from './in-play-event';
-export var BlockFailure;
-(function (BlockFailure) {
-    BlockFailure[BlockFailure["NO_FAILURE"] = 0] = "NO_FAILURE";
-    BlockFailure[BlockFailure["FAULT"] = 1] = "FAULT";
-    BlockFailure[BlockFailure["MISS"] = 2] = "MISS";
-    BlockFailure[BlockFailure["OUT_OF_BOUNDS"] = 3] = "OUT_OF_BOUNDS";
-    BlockFailure[BlockFailure["WIPE"] = 4] = "WIPE";
-    BlockFailure[BlockFailure["TOOL"] = 5] = "TOOL";
-})(BlockFailure || (BlockFailure = {}));
-export var BlockType;
-(function (BlockType) {
-    BlockType[BlockType["NO_BLOCKER"] = 0] = "NO_BLOCKER";
-    BlockType[BlockType["SINGLE"] = 1] = "SINGLE";
-    BlockType[BlockType["DOUBLE"] = 2] = "DOUBLE";
-    BlockType[BlockType["TRIPLE"] = 3] = "TRIPLE";
-})(BlockType || (BlockType = {}));
+export var BlockFailureEnum;
+(function (BlockFailureEnum) {
+    BlockFailureEnum[BlockFailureEnum["NO_FAILURE"] = 0] = "NO_FAILURE";
+    BlockFailureEnum[BlockFailureEnum["FAULT"] = 1] = "FAULT";
+    BlockFailureEnum[BlockFailureEnum["MISS"] = 2] = "MISS";
+    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 = {}));
 export class Block extends InPlayEvent {
     constructor({ id, order, score, player, target, failure, type, modifier, eventType, blockers }) {
         super({ id, order, score, player, target, modifier, eventType });
@@ -28,22 +28,22 @@ export class Block extends InPlayEvent {
             throw new Error('UNKNOWN_TYPE');
         let bmod;
         switch (type) {
-            case BlockType.NO_BLOCKER:
+            case BlockTypeEnum.NO_BLOCKER:
                 return 0;
-            case BlockType.SINGLE:
+            case BlockTypeEnum.SINGLE:
                 bmod = 1;
                 break;
-            case BlockType.DOUBLE:
+            case BlockTypeEnum.DOUBLE:
                 bmod = 1.2;
                 break;
-            case BlockType.TRIPLE:
+            case BlockTypeEnum.TRIPLE:
                 bmod = 1.4;
                 break;
             default:
                 throw new Error('UNKNOWN_TYPE');
         }
         const total = blockers.reduce((score, player) => {
-            return score + Block.calculateScore(player.stats, 'BLOCK', BlockType[type]);
+            return score + Block.calculateScore(player.stats, 'BLOCK', BlockTypeEnum[type]);
         }, 0);
         const avg = total / blockers.length;
         return avg * bmod * modifier;

package/dist/esm/src/service/event/block.test.js

@@ -1,8 +1,8 @@
 import { describe, expect, test } from '@jest/globals';
-import { Block, BlockFailure, BlockType } from './block';
+import { Block, BlockFailureEnum, BlockTypeEnum } from './block';
 import { player } from '../player/__stubs__';
-import { CourtTarget } from '../match';
-import { EventType } from './rally-event';
+import { CourtTargetEnum } from '../match';
+import { EventTypeEnum } from './rally-event';
 import { v4 as uuidv4 } from 'uuid';
 describe('Block Test Module', () => {
     let none;
@@ -15,10 +15,10 @@ describe('Block Test Module', () => {
             id: uuidv4(),
             order: 1,
             player: player,
-            target: CourtTarget.OPPONENT_RIGHT_BACK,
-            failure: BlockFailure.NO_FAILURE,
-            type: BlockType.NO_BLOCKER,
-            eventType: EventType.BLOCK,
+            target: CourtTargetEnum.OPPONENT_RIGHT_BACK,
+            failure: BlockFailureEnum.NO_FAILURE,
+            type: BlockTypeEnum.NO_BLOCKER,
+            eventType: EventTypeEnum.BLOCK,
             modifier: 1,
             blockers: [],
             score: Block.getScore([], 1)
@@ -27,10 +27,10 @@ describe('Block Test Module', () => {
             id: uuidv4(),
             order: 1,
             player: player,
-            target: CourtTarget.OPPONENT_RIGHT_BACK,
-            failure: BlockFailure.NO_FAILURE,
-            type: BlockType.SINGLE,
-            eventType: EventType.BLOCK,
+            target: CourtTargetEnum.OPPONENT_RIGHT_BACK,
+            failure: BlockFailureEnum.NO_FAILURE,
+            type: BlockTypeEnum.SINGLE,
+            eventType: EventTypeEnum.BLOCK,
             modifier: 1,
             blockers: [player],
             score: Block.getScore([player], 1)
@@ -39,10 +39,10 @@ describe('Block Test Module', () => {
             id: uuidv4(),
             order: 1,
             player: player,
-            target: CourtTarget.OPPONENT_RIGHT_BACK,
-            failure: BlockFailure.NO_FAILURE,
-            type: BlockType.DOUBLE,
-            eventType: EventType.BLOCK,
+            target: CourtTargetEnum.OPPONENT_RIGHT_BACK,
+            failure: BlockFailureEnum.NO_FAILURE,
+            type: BlockTypeEnum.DOUBLE,
+            eventType: EventTypeEnum.BLOCK,
             modifier: 1,
             blockers: [player, player],
             score: Block.getScore([player, player], 1)
@@ -51,10 +51,10 @@ describe('Block Test Module', () => {
             id: uuidv4(),
             order: 1,
             player: player,
-            target: CourtTarget.OPPONENT_RIGHT_BACK,
-            failure: BlockFailure.NO_FAILURE,
-            type: BlockType.TRIPLE,
-            eventType: EventType.BLOCK,
+            target: CourtTargetEnum.OPPONENT_RIGHT_BACK,
+            failure: BlockFailureEnum.NO_FAILURE,
+            type: BlockTypeEnum.TRIPLE,
+            eventType: EventTypeEnum.BLOCK,
             modifier: 1,
             blockers: [player, player, player],
             score: Block.getScore([player, player, player], 1)
@@ -63,22 +63,22 @@ describe('Block Test Module', () => {
             id: uuidv4(),
             order: 1,
             player: player,
-            target: CourtTarget.NO_TARGET,
-            failure: BlockFailure.FAULT,
-            type: BlockType.TRIPLE,
-            eventType: EventType.BLOCK,
+            target: CourtTargetEnum.NO_TARGET,
+            failure: BlockFailureEnum.FAULT,
+            type: BlockTypeEnum.TRIPLE,
+            eventType: EventTypeEnum.BLOCK,
             modifier: 1,
             blockers: [player],
             score: Block.getScore([player], 1)
         });
     });
     test('Should instantiate object properly', () => {
-        expect(block.target).toBe(CourtTarget.OPPONENT_RIGHT_BACK);
-        expect(block.type).toBe(BlockType.SINGLE);
-        expect(block.eventType).toBe(EventType.BLOCK);
+        expect(block.target).toBe(CourtTargetEnum.OPPONENT_RIGHT_BACK);
+        expect(block.type).toBe(BlockTypeEnum.SINGLE);
+        expect(block.eventType).toBe(EventTypeEnum.BLOCK);
         expect(block.player.id).toBe(player.id);
-        expect(block.failure).toBe(BlockFailure.NO_FAILURE);
-        expect(failed.failure).toBe(BlockFailure.FAULT);
+        expect(block.failure).toBe(BlockFailureEnum.NO_FAILURE);
+        expect(failed.failure).toBe(BlockFailureEnum.FAULT);
         expect(block.modifier).toBe(1);
     });
     // getScore Tests

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

@@ -1,15 +1,15 @@
 import { RallyEvent, RallyEventOpts } from './rally-event';
-import { CourtTarget } from '../match';
+import { CourtTargetEnum } from '../match';
 import { PerformanceStats } from '../player';
 export interface InPlayEventOpts extends RallyEventOpts {
-    readonly target: CourtTarget;
+    readonly target: CourtTargetEnum;
     readonly modifier: number;
     readonly score: number;
 }
 export declare abstract class InPlayEvent extends RallyEvent {
     abstract failure: number;
     abstract type: number;
-    readonly target: CourtTarget;
+    readonly target: CourtTargetEnum;
     readonly modifier: number;
     readonly score: number;
     protected constructor(opts: InPlayEventOpts);

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

@@ -1,11 +1,10 @@
-import { Score } from './score';
-import { Set, SetFailure, SetType } from './set';
-import { Block, BlockFailure, BlockType } from './block';
-import { Serve, ServeFailure, ServeType } from './serve';
-import { InPlayEvent, InPlayEventOpts } from './in-play-event';
-import { EventType, RallyEvent, RallyEventOpts } from './rally-event';
-import { Reception, ReceptionFailure, ReceptionType } from './reception';
-import { Spike, SpikeFailure, SpikeType } from './spike';
-import { Substitution } from './substitution';
-import { LiberoReplacement, LiberoReplacementType } from './libero-replacement';
-export { Spike, SpikeFailure, SpikeType, ServeType, Set, SetFailure, SetType, ReceptionFailure, ReceptionType, BlockFailure, BlockType, Block, ServeFailure, Serve, EventType, RallyEvent, RallyEventOpts, InPlayEventOpts, InPlayEvent, Reception, Substitution, LiberoReplacementType, LiberoReplacement, Score };
+export * from './score';
+export * from './set';
+export * from './block';
+export * from './serve';
+export * from './in-play-event';
+export * from './rally-event';
+export * from './reception';
+export * from './spike';
+export * from './substitution';
+export * from './libero-replacement';

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

@@ -1,11 +1,10 @@
-import { Score } from './score';
-import { Set, SetFailure, SetType } from './set';
-import { Block, BlockFailure, BlockType } from './block';
-import { Serve, ServeFailure, ServeType } from './serve';
-import { InPlayEvent } from './in-play-event';
-import { EventType, RallyEvent } from './rally-event';
-import { Reception, ReceptionFailure, ReceptionType } from './reception';
-import { Spike, SpikeFailure, SpikeType } from './spike';
-import { Substitution } from './substitution';
-import { LiberoReplacement, LiberoReplacementType, } from './libero-replacement';
-export { Spike, SpikeFailure, SpikeType, ServeType, Set, SetFailure, SetType, ReceptionFailure, ReceptionType, BlockFailure, BlockType, Block, ServeFailure, Serve, EventType, RallyEvent, InPlayEvent, Reception, Substitution, LiberoReplacementType, LiberoReplacement, Score };
+export * from './score';
+export * from './set';
+export * from './block';
+export * from './serve';
+export * from './in-play-event';
+export * from './rally-event';
+export * from './reception';
+export * from './spike';
+export * from './substitution';
+export * from './libero-replacement';

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

@@ -3,14 +3,14 @@ import { Player } from '../player';
 interface LiberoReplacementOpts extends RallyEventOpts {
     readonly player: Player;
     readonly libero: Player;
-    readonly type: LiberoReplacementType;
+    readonly type: LiberoReplacementTypeEnum;
 }
-export declare enum LiberoReplacementType {
+export declare enum LiberoReplacementTypeEnum {
     LIBERO_IN = 0,
     LIBERO_OUT = 1
 }
 export declare class LiberoReplacement extends RallyEvent {
-    readonly type: LiberoReplacementType;
+    readonly type: LiberoReplacementTypeEnum;
     readonly libero: Player;
     constructor({ id, order, player, type, libero }: LiberoReplacementOpts);
 }

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

@@ -1,12 +1,12 @@
-import { EventType, RallyEvent } from './rally-event';
-export var LiberoReplacementType;
-(function (LiberoReplacementType) {
-    LiberoReplacementType[LiberoReplacementType["LIBERO_IN"] = 0] = "LIBERO_IN";
-    LiberoReplacementType[LiberoReplacementType["LIBERO_OUT"] = 1] = "LIBERO_OUT";
-})(LiberoReplacementType || (LiberoReplacementType = {}));
+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 = {}));
 export class LiberoReplacement extends RallyEvent {
     constructor({ id, order, player, type, libero }) {
-        super({ id, order, player, eventType: EventType.LIBERO_REPLACEMENT });
+        super({ id, order, player, eventType: EventTypeEnum.LIBERO_REPLACEMENT });
         this.type = type;
         this.libero = libero;
     }

package/dist/esm/src/service/event/libero-replacement.test.js

@@ -1,7 +1,7 @@
 import { beforeEach, describe, expect, test } from '@jest/globals';
-import { EventType } from './rally-event';
+import { EventTypeEnum } from './rally-event';
 import { players } from '../player/__stubs__';
-import { LiberoReplacement, LiberoReplacementType } from './libero-replacement';
+import { LiberoReplacement, LiberoReplacementTypeEnum } from './libero-replacement';
 import { v4 as uuidv4 } from 'uuid';
 describe('LiberoReplacement Test Module', () => {
     let _in;
@@ -12,23 +12,23 @@ describe('LiberoReplacement Test Module', () => {
             order: 1,
             player: players[0],
             libero: players[1],
-            type: LiberoReplacementType.LIBERO_IN,
-            eventType: EventType.LIBERO_REPLACEMENT
+            type: LiberoReplacementTypeEnum.LIBERO_IN,
+            eventType: EventTypeEnum.LIBERO_REPLACEMENT
         });
         _out = new LiberoReplacement({
             id: uuidv4(),
             order: 1,
             player: players[0],
             libero: players[1],
-            type: LiberoReplacementType.LIBERO_OUT,
-            eventType: EventType.LIBERO_REPLACEMENT
+            type: LiberoReplacementTypeEnum.LIBERO_OUT,
+            eventType: EventTypeEnum.LIBERO_REPLACEMENT
         });
     });
     test('Should instantiate object properly', () => {
         expect(_in.libero.id).toBe('e92f4abb-66f4-4b6c-a602-258404d04484');
         expect(_in.player.id).toBe('622c36dc-f2d2-44b3-a744-667ea53218b7');
-        expect(_in.type).toBe(LiberoReplacementType.LIBERO_IN);
-        expect(_out.type).toBe(LiberoReplacementType.LIBERO_OUT);
-        expect(_in.eventType).toBe(EventType.LIBERO_REPLACEMENT);
+        expect(_in.type).toBe(LiberoReplacementTypeEnum.LIBERO_IN);
+        expect(_out.type).toBe(LiberoReplacementTypeEnum.LIBERO_OUT);
+        expect(_in.eventType).toBe(EventTypeEnum.LIBERO_REPLACEMENT);
     });
 });

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

@@ -1,5 +1,5 @@
 import { Player } from '../player';
-export declare enum EventType {
+export declare enum EventTypeEnum {
     LIBERO_REPLACEMENT = 0,
     SUBSTITUTION = 1,
     SERVE = 2,
@@ -12,13 +12,13 @@ export declare enum EventType {
 export interface RallyEventOpts {
     readonly id: string;
     readonly player: Player;
-    readonly eventType: EventType;
+    readonly eventType: EventTypeEnum;
     readonly order: number;
 }
 export declare abstract class RallyEvent {
     readonly id: string;
     readonly order: number;
     readonly player: Player;
-    readonly eventType: EventType;
+    readonly eventType: EventTypeEnum;
     protected constructor({ id, eventType, player, order }: RallyEventOpts);
 }

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

@@ -1,14 +1,14 @@
-export var EventType;
-(function (EventType) {
-    EventType[EventType["LIBERO_REPLACEMENT"] = 0] = "LIBERO_REPLACEMENT";
-    EventType[EventType["SUBSTITUTION"] = 1] = "SUBSTITUTION";
-    EventType[EventType["SERVE"] = 2] = "SERVE";
-    EventType[EventType["RECEPTION"] = 3] = "RECEPTION";
-    EventType[EventType["SET"] = 4] = "SET";
-    EventType[EventType["SPIKE"] = 5] = "SPIKE";
-    EventType[EventType["BLOCK"] = 6] = "BLOCK";
-    EventType[EventType["SCORE"] = 7] = "SCORE";
-})(EventType || (EventType = {}));
+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["SCORE"] = 7] = "SCORE";
+})(EventTypeEnum || (EventTypeEnum = {}));
 export class RallyEvent {
     constructor({ id, eventType, player, order }) {
         this.id = id;

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

@@ -1,12 +1,12 @@
 import { PerformanceStats } from '../player';
 import { InPlayEvent, InPlayEventOpts } from './in-play-event';
-export declare enum ReceptionType {
+export declare enum ReceptionTypeEnum {
     DIG = 0,
     OVERHAND = 1,
     ONE_HAND = 2,
     OTHER_BODY_PART = 3
 }
-export declare enum ReceptionFailure {
+export declare enum ReceptionFailureEnum {
     NO_FAILURE = 0,
     FAULT = 1,
     MISS = 2,
@@ -14,13 +14,13 @@ export declare enum ReceptionFailure {
     BAD_PASS = 4
 }
 interface ReceptionOpts extends InPlayEventOpts {
-    readonly type: ReceptionType;
-    readonly failure: ReceptionFailure;
+    readonly type: ReceptionTypeEnum;
+    readonly failure: ReceptionFailureEnum;
 }
 export declare class Reception extends InPlayEvent {
-    readonly failure: ReceptionFailure;
-    readonly type: ReceptionType;
+    readonly failure: ReceptionFailureEnum;
+    readonly type: ReceptionTypeEnum;
     constructor({ id, order, score, player, target, failure, type, eventType, modifier }: ReceptionOpts);
-    static getScore(stats: PerformanceStats, type: ReceptionType, modifier: number): number;
+    static getScore(stats: PerformanceStats, type: ReceptionTypeEnum, modifier: number): number;
 }
 export {};

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

@@ -1,19 +1,19 @@
 import { InPlayEvent } from './in-play-event';
-export var ReceptionType;
-(function (ReceptionType) {
-    ReceptionType[ReceptionType["DIG"] = 0] = "DIG";
-    ReceptionType[ReceptionType["OVERHAND"] = 1] = "OVERHAND";
-    ReceptionType[ReceptionType["ONE_HAND"] = 2] = "ONE_HAND";
-    ReceptionType[ReceptionType["OTHER_BODY_PART"] = 3] = "OTHER_BODY_PART";
-})(ReceptionType || (ReceptionType = {}));
-export var ReceptionFailure;
-(function (ReceptionFailure) {
-    ReceptionFailure[ReceptionFailure["NO_FAILURE"] = 0] = "NO_FAILURE";
-    ReceptionFailure[ReceptionFailure["FAULT"] = 1] = "FAULT";
-    ReceptionFailure[ReceptionFailure["MISS"] = 2] = "MISS";
-    ReceptionFailure[ReceptionFailure["OUT_OF_BOUNDS"] = 3] = "OUT_OF_BOUNDS";
-    ReceptionFailure[ReceptionFailure["BAD_PASS"] = 4] = "BAD_PASS";
-})(ReceptionFailure || (ReceptionFailure = {}));
+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 = {}));
 export class Reception extends InPlayEvent {
     constructor({ id, order, score, player, target, failure, type, eventType, modifier }) {
         super({ id, order, score, player, target, eventType, modifier });
@@ -21,6 +21,6 @@ export class Reception extends InPlayEvent {
         this.failure = failure;
     }
     static getScore(stats, type, modifier) {
-        return Reception.calculateScore(stats, 'RECEPTION', ReceptionType[type]) * modifier;
+        return Reception.calculateScore(stats, 'RECEPTION', ReceptionTypeEnum[type]) * modifier;
     }
 }