volleyballsimtypes 0.0.74 → 0.0.76

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

@@ -1,8 +1,8 @@
 import { describe, expect, test } from '@jest/globals';
-import { Reception, ReceptionFailure, ReceptionType } from './reception';
+import { Reception, ReceptionFailureEnum, ReceptionTypeEnum } from './reception';
 import { player } from '../player/__stubs__';
-import { CourtTarget } from '../match';
-import { EventType } from './rally-event';
+import { CourtTargetEnum } from '../match';
+import { EventTypeEnum } from './rally-event';
 describe('Reception Test Module', () => {
     let reception;
     let failed;
@@ -12,10 +12,10 @@ describe('Reception Test Module', () => {
             id: '622c36dc-f2d2-44b3-a744-667ea53218b7',
             order: 0,
             player: player,
-            target: CourtTarget.OPPONENT_RIGHT_BACK,
-            failure: ReceptionFailure.NO_FAILURE,
-            type: ReceptionType.DIG,
-            eventType: EventType.RECEPTION,
+            target: CourtTargetEnum.OPPONENT_RIGHT_BACK,
+            failure: ReceptionFailureEnum.NO_FAILURE,
+            type: ReceptionTypeEnum.DIG,
+            eventType: EventTypeEnum.RECEPTION,
             modifier: 1
         });
         failed = new Reception({
@@ -23,20 +23,20 @@ describe('Reception Test Module', () => {
             id: '622c36dc-f2d2-44b3-a744-667ea53218b7',
             order: 0,
             player: player,
-            target: CourtTarget.NO_TARGET,
-            failure: ReceptionFailure.OUT_OF_BOUNDS,
-            type: ReceptionType.OTHER_BODY_PART,
-            eventType: EventType.RECEPTION,
+            target: CourtTargetEnum.NO_TARGET,
+            failure: ReceptionFailureEnum.OUT_OF_BOUNDS,
+            type: ReceptionTypeEnum.OTHER_BODY_PART,
+            eventType: EventTypeEnum.RECEPTION,
             modifier: 1
         });
     });
     test('Should instantiate object properly', () => {
-        expect(reception.target).toBe(CourtTarget.OPPONENT_RIGHT_BACK);
-        expect(reception.type).toBe(ReceptionType.DIG);
-        expect(reception.eventType).toBe(EventType.RECEPTION);
+        expect(reception.target).toBe(CourtTargetEnum.OPPONENT_RIGHT_BACK);
+        expect(reception.type).toBe(ReceptionTypeEnum.DIG);
+        expect(reception.eventType).toBe(EventTypeEnum.RECEPTION);
         expect(reception.player.id).toBe(player.id);
-        expect(reception.failure).toBe(ReceptionFailure.NO_FAILURE);
-        expect(failed.failure).toBe(ReceptionFailure.OUT_OF_BOUNDS);
+        expect(reception.failure).toBe(ReceptionFailureEnum.NO_FAILURE);
+        expect(failed.failure).toBe(ReceptionFailureEnum.OUT_OF_BOUNDS);
         expect(reception.modifier).toBe(1);
     });
     // getScore Tests

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

@@ -2,20 +2,20 @@ import { beforeEach, describe, expect, test } from '@jest/globals';
 import { Score } from './score';
 import { player } from '../player/__stubs__';
 import { team } from '../team/__stubs__';
-import { EventType } from './rally-event';
+import { EventTypeEnum } from './rally-event';
 describe('Score Test Module', () => {
     let score;
     beforeEach(() => {
         score = new Score({
             id: '622c36dc-f2d2-44b3-a744-667ea53218b7',
             order: 0,
-            eventType: EventType.SCORE,
+            eventType: EventTypeEnum.SCORE,
             player: player,
             team
         });
     });
     test('Should instantiate object properly', () => {
-        expect(score.eventType).toBe(EventType.SCORE);
+        expect(score.eventType).toBe(EventTypeEnum.SCORE);
         expect(score.player.id).toBe('e92f4abb-66f4-4b6c-a602-258404d04484');
         expect(score.team.id).toBe('426b5b9b-5be7-4963-92eb-71b7a3b29ffd');
     });

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

@@ -1,13 +1,13 @@
 import { InPlayEvent, InPlayEventOpts } from './in-play-event';
 import { PerformanceStats } from '../player';
-export declare enum ServeType {
+export declare enum ServeTypeEnum {
     UNDERHAND = 0,
     OVERHAND_TOPSPIN = 1,
     OVERHAND_FLOAT = 2,
     JUMP_TOPSPIN = 3,
     JUMP_FLOAT = 4
 }
-export declare enum ServeFailure {
+export declare enum ServeFailureEnum {
     NO_FAILURE = 0,
     FAULT = 1,
     MISS = 2,
@@ -15,13 +15,13 @@ export declare enum ServeFailure {
     OUT_OF_BOUNDS = 4
 }
 interface ServeOpts extends InPlayEventOpts {
-    readonly type: ServeType;
-    readonly failure: ServeFailure;
+    readonly type: ServeTypeEnum;
+    readonly failure: ServeFailureEnum;
 }
 export declare class Serve extends InPlayEvent {
-    readonly failure: ServeFailure;
-    readonly type: ServeType;
+    readonly failure: ServeFailureEnum;
+    readonly type: ServeTypeEnum;
     constructor({ id, order, score, player, target, failure, type, eventType, modifier }: ServeOpts);
-    static getScore(stats: PerformanceStats, type: ServeType, modifier: number): number;
+    static getScore(stats: PerformanceStats, type: ServeTypeEnum, modifier: number): number;
 }
 export {};

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

@@ -1,20 +1,20 @@
 import { InPlayEvent } from './in-play-event';
-export var ServeType;
-(function (ServeType) {
-    ServeType[ServeType["UNDERHAND"] = 0] = "UNDERHAND";
-    ServeType[ServeType["OVERHAND_TOPSPIN"] = 1] = "OVERHAND_TOPSPIN";
-    ServeType[ServeType["OVERHAND_FLOAT"] = 2] = "OVERHAND_FLOAT";
-    ServeType[ServeType["JUMP_TOPSPIN"] = 3] = "JUMP_TOPSPIN";
-    ServeType[ServeType["JUMP_FLOAT"] = 4] = "JUMP_FLOAT";
-})(ServeType || (ServeType = {}));
-export var ServeFailure;
-(function (ServeFailure) {
-    ServeFailure[ServeFailure["NO_FAILURE"] = 0] = "NO_FAILURE";
-    ServeFailure[ServeFailure["FAULT"] = 1] = "FAULT";
-    ServeFailure[ServeFailure["MISS"] = 2] = "MISS";
-    ServeFailure[ServeFailure["NET"] = 3] = "NET";
-    ServeFailure[ServeFailure["OUT_OF_BOUNDS"] = 4] = "OUT_OF_BOUNDS";
-})(ServeFailure || (ServeFailure = {}));
+export var ServeTypeEnum;
+(function (ServeTypeEnum) {
+    ServeTypeEnum[ServeTypeEnum["UNDERHAND"] = 0] = "UNDERHAND";
+    ServeTypeEnum[ServeTypeEnum["OVERHAND_TOPSPIN"] = 1] = "OVERHAND_TOPSPIN";
+    ServeTypeEnum[ServeTypeEnum["OVERHAND_FLOAT"] = 2] = "OVERHAND_FLOAT";
+    ServeTypeEnum[ServeTypeEnum["JUMP_TOPSPIN"] = 3] = "JUMP_TOPSPIN";
+    ServeTypeEnum[ServeTypeEnum["JUMP_FLOAT"] = 4] = "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 = {}));
 export class Serve extends InPlayEvent {
     constructor({ id, order, score, player, target, failure, type, eventType, modifier }) {
         super({ id, order, score, player, target, eventType, modifier });
@@ -22,6 +22,6 @@ export class Serve extends InPlayEvent {
         this.failure = failure;
     }
     static getScore(stats, type, modifier) {
-        return Serve.calculateScore(stats, 'SERVE', ServeType[type]) * modifier;
+        return Serve.calculateScore(stats, 'SERVE', ServeTypeEnum[type]) * modifier;
     }
 }

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

@@ -1,8 +1,8 @@
 import { describe, expect, test } from '@jest/globals';
-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';
 describe('Serve Test Module', () => {
     let serve;
     let failed;
@@ -12,10 +12,10 @@ describe('Serve Test Module', () => {
             id: '622c36dc-f2d2-44b3-a744-667ea53218b7',
             order: 0,
             player: player,
-            target: CourtTarget.OPPONENT_RIGHT_BACK,
-            failure: ServeFailure.NO_FAILURE,
-            type: ServeType.JUMP_TOPSPIN,
-            eventType: EventType.SERVE,
+            target: CourtTargetEnum.OPPONENT_RIGHT_BACK,
+            failure: ServeFailureEnum.NO_FAILURE,
+            type: ServeTypeEnum.JUMP_TOPSPIN,
+            eventType: EventTypeEnum.SERVE,
             modifier: 1
         });
         failed = new Serve({
@@ -23,20 +23,20 @@ describe('Serve Test Module', () => {
             id: '622c36dc-f2d2-44b3-a744-667ea53218b7',
             order: 0,
             player: player,
-            target: CourtTarget.NO_TARGET,
-            failure: ServeFailure.NET,
-            type: ServeType.UNDERHAND,
-            eventType: EventType.SERVE,
+            target: CourtTargetEnum.NO_TARGET,
+            failure: ServeFailureEnum.NET,
+            type: ServeTypeEnum.UNDERHAND,
+            eventType: EventTypeEnum.SERVE,
             modifier: 1
         });
     });
     test('Should instantiate object properly', () => {
-        expect(serve.target).toBe(CourtTarget.OPPONENT_RIGHT_BACK);
-        expect(serve.type).toBe(ServeType.JUMP_TOPSPIN);
-        expect(serve.eventType).toBe(EventType.SERVE);
+        expect(serve.target).toBe(CourtTargetEnum.OPPONENT_RIGHT_BACK);
+        expect(serve.type).toBe(ServeTypeEnum.JUMP_TOPSPIN);
+        expect(serve.eventType).toBe(EventTypeEnum.SERVE);
         expect(serve.player.id).toBe(player.id);
-        expect(serve.failure).toBe(ServeFailure.NO_FAILURE);
-        expect(failed.failure).toBe(ServeFailure.NET);
+        expect(serve.failure).toBe(ServeFailureEnum.NO_FAILURE);
+        expect(failed.failure).toBe(ServeFailureEnum.NET);
         expect(serve.modifier).toBe(1);
     });
     // getScore Tests

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

@@ -1,12 +1,12 @@
 import { PerformanceStats } from '../player';
 import { InPlayEvent, InPlayEventOpts } from './in-play-event';
-export declare enum SetType {
+export declare enum SetTypeEnum {
     OVERHAND = 0,
     UNDERHAND = 1,
     SPIKE = 2,
     DUMP = 3
 }
-export declare enum SetFailure {
+export declare enum SetFailureEnum {
     NO_FAILURE = 0,
     FAULT = 1,
     MISS = 2,
@@ -14,13 +14,13 @@ export declare enum SetFailure {
     OUT_OF_BOUNDS = 4
 }
 interface SetOpts extends InPlayEventOpts {
-    readonly type: SetType;
-    readonly failure: SetFailure;
+    readonly type: SetTypeEnum;
+    readonly failure: SetFailureEnum;
 }
 export declare class Set extends InPlayEvent {
-    readonly failure: SetFailure;
-    readonly type: SetType;
+    readonly failure: SetFailureEnum;
+    readonly type: SetTypeEnum;
     constructor({ id, order, score, player, target, failure, type, eventType, modifier }: SetOpts);
-    static getScore(stats: PerformanceStats, type: SetType, modifier: number): number;
+    static getScore(stats: PerformanceStats, type: SetTypeEnum, modifier: number): number;
 }
 export {};

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

@@ -1,19 +1,19 @@
 import { InPlayEvent } from './in-play-event';
-export var SetType;
-(function (SetType) {
-    SetType[SetType["OVERHAND"] = 0] = "OVERHAND";
-    SetType[SetType["UNDERHAND"] = 1] = "UNDERHAND";
-    SetType[SetType["SPIKE"] = 2] = "SPIKE";
-    SetType[SetType["DUMP"] = 3] = "DUMP";
-})(SetType || (SetType = {}));
-export var SetFailure;
-(function (SetFailure) {
-    SetFailure[SetFailure["NO_FAILURE"] = 0] = "NO_FAILURE";
-    SetFailure[SetFailure["FAULT"] = 1] = "FAULT";
-    SetFailure[SetFailure["MISS"] = 2] = "MISS";
-    SetFailure[SetFailure["BAD_PASS"] = 3] = "BAD_PASS";
-    SetFailure[SetFailure["OUT_OF_BOUNDS"] = 4] = "OUT_OF_BOUNDS";
-})(SetFailure || (SetFailure = {}));
+export var SetTypeEnum;
+(function (SetTypeEnum) {
+    SetTypeEnum[SetTypeEnum["OVERHAND"] = 0] = "OVERHAND";
+    SetTypeEnum[SetTypeEnum["UNDERHAND"] = 1] = "UNDERHAND";
+    SetTypeEnum[SetTypeEnum["SPIKE"] = 2] = "SPIKE";
+    SetTypeEnum[SetTypeEnum["DUMP"] = 3] = "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 = {}));
 export class Set 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 Set extends InPlayEvent {
         this.failure = failure;
     }
     static getScore(stats, type, modifier) {
-        return Set.calculateScore(stats, 'SET', SetType[type]) * modifier;
+        return Set.calculateScore(stats, 'SET', SetTypeEnum[type]) * modifier;
     }
 }

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

@@ -1,8 +1,8 @@
 import { describe, expect, test } from '@jest/globals';
-import { Set, SetFailure, SetType } from './set';
+import { Set, SetFailureEnum, SetTypeEnum } from './set';
 import { player } from '../player/__stubs__';
-import { CourtTarget } from '../match';
-import { EventType } from './rally-event';
+import { CourtTargetEnum } from '../match';
+import { EventTypeEnum } from './rally-event';
 describe('Set Test Module', () => {
     let set;
     let failed;
@@ -12,10 +12,10 @@ describe('Set Test Module', () => {
             id: '622c36dc-f2d2-44b3-a744-667ea53218b7',
             order: 0,
             player: player,
-            target: CourtTarget.OPPONENT_RIGHT_BACK,
-            failure: SetFailure.NO_FAILURE,
-            type: SetType.OVERHAND,
-            eventType: EventType.SET,
+            target: CourtTargetEnum.OPPONENT_RIGHT_BACK,
+            failure: SetFailureEnum.NO_FAILURE,
+            type: SetTypeEnum.OVERHAND,
+            eventType: EventTypeEnum.SET,
             modifier: 1
         });
         failed = new Set({
@@ -23,20 +23,20 @@ describe('Set Test Module', () => {
             id: '622c36dc-f2d2-44b3-a744-667ea53218b7',
             order: 0,
             player: player,
-            target: CourtTarget.NO_TARGET,
-            failure: SetFailure.OUT_OF_BOUNDS,
-            type: SetType.DUMP,
-            eventType: EventType.SET,
+            target: CourtTargetEnum.NO_TARGET,
+            failure: SetFailureEnum.OUT_OF_BOUNDS,
+            type: SetTypeEnum.DUMP,
+            eventType: EventTypeEnum.SET,
             modifier: 1
         });
     });
     test('Should instantiate object properly', () => {
-        expect(set.target).toBe(CourtTarget.OPPONENT_RIGHT_BACK);
-        expect(set.type).toBe(SetType.OVERHAND);
-        expect(set.eventType).toBe(EventType.SET);
+        expect(set.target).toBe(CourtTargetEnum.OPPONENT_RIGHT_BACK);
+        expect(set.type).toBe(SetTypeEnum.OVERHAND);
+        expect(set.eventType).toBe(EventTypeEnum.SET);
         expect(set.player.id).toBe(player.id);
-        expect(set.failure).toBe(SetFailure.NO_FAILURE);
-        expect(failed.failure).toBe(SetFailure.OUT_OF_BOUNDS);
+        expect(set.failure).toBe(SetFailureEnum.NO_FAILURE);
+        expect(failed.failure).toBe(SetFailureEnum.OUT_OF_BOUNDS);
         expect(set.modifier).toBe(1);
     });
     // getScore Tests

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

@@ -1,6 +1,6 @@
 import { InPlayEvent, InPlayEventOpts } from './in-play-event';
 import { Player } from '../player';
-export declare enum SpikeType {
+export declare enum SpikeTypeEnum {
     CROSS_SHOT = 0,
     LINE_SHOT = 1,
     TOOL_SHOT = 2,
@@ -8,7 +8,7 @@ export declare enum SpikeType {
     DOWN_BALL = 4,
     OVERHAND = 5
 }
-export declare enum SpikeFailure {
+export declare enum SpikeFailureEnum {
     NO_FAILURE = 0,
     FAULT = 1,
     MISS = 2,
@@ -16,13 +16,13 @@ export declare enum SpikeFailure {
     NET = 4
 }
 interface SpikeOpts extends InPlayEventOpts {
-    readonly type: SpikeType;
-    readonly failure: SpikeFailure;
+    readonly type: SpikeTypeEnum;
+    readonly failure: SpikeFailureEnum;
 }
 export declare class Spike extends InPlayEvent {
-    readonly failure: SpikeFailure;
-    readonly type: SpikeType;
+    readonly failure: SpikeFailureEnum;
+    readonly type: SpikeTypeEnum;
     constructor({ id, order, score, player, target, failure, type, eventType, modifier }: SpikeOpts);
-    static getScore(player: Player, type: SpikeType, modifier: number, isBackRow: boolean): number;
+    static getScore(player: Player, type: SpikeTypeEnum, modifier: number, isBackRow: boolean): number;
 }
 export {};

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

@@ -1,21 +1,21 @@
 import { InPlayEvent } from './in-play-event';
-export var SpikeType;
-(function (SpikeType) {
-    SpikeType[SpikeType["CROSS_SHOT"] = 0] = "CROSS_SHOT";
-    SpikeType[SpikeType["LINE_SHOT"] = 1] = "LINE_SHOT";
-    SpikeType[SpikeType["TOOL_SHOT"] = 2] = "TOOL_SHOT";
-    SpikeType[SpikeType["TIP"] = 3] = "TIP";
-    SpikeType[SpikeType["DOWN_BALL"] = 4] = "DOWN_BALL";
-    SpikeType[SpikeType["OVERHAND"] = 5] = "OVERHAND";
-})(SpikeType || (SpikeType = {}));
-export var SpikeFailure;
-(function (SpikeFailure) {
-    SpikeFailure[SpikeFailure["NO_FAILURE"] = 0] = "NO_FAILURE";
-    SpikeFailure[SpikeFailure["FAULT"] = 1] = "FAULT";
-    SpikeFailure[SpikeFailure["MISS"] = 2] = "MISS";
-    SpikeFailure[SpikeFailure["OUT_OF_BOUNDS"] = 3] = "OUT_OF_BOUNDS";
-    SpikeFailure[SpikeFailure["NET"] = 4] = "NET";
-})(SpikeFailure || (SpikeFailure = {}));
+export var SpikeTypeEnum;
+(function (SpikeTypeEnum) {
+    SpikeTypeEnum[SpikeTypeEnum["CROSS_SHOT"] = 0] = "CROSS_SHOT";
+    SpikeTypeEnum[SpikeTypeEnum["LINE_SHOT"] = 1] = "LINE_SHOT";
+    SpikeTypeEnum[SpikeTypeEnum["TOOL_SHOT"] = 2] = "TOOL_SHOT";
+    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 = {}));
 export class Spike extends InPlayEvent {
     constructor({ id, order, score, player, target, failure, type, eventType, modifier }) {
         super({ id, order, score, player, target, eventType, modifier });
@@ -23,8 +23,8 @@ export class Spike extends InPlayEvent {
         this.failure = failure;
     }
     static getScore(player, type, modifier, isBackRow) {
-        let score = Spike.calculateScore(player.stats, 'SPIKE', SpikeType[type]);
-        if (![SpikeType.DOWN_BALL, SpikeType.OVERHAND, SpikeType.TIP].includes(type) && isBackRow) {
+        let score = Spike.calculateScore(player.stats, 'SPIKE', SpikeTypeEnum[type]);
+        if (![SpikeTypeEnum.DOWN_BALL, SpikeTypeEnum.OVERHAND, SpikeTypeEnum.TIP].includes(type) && isBackRow) {
             score = score * 0.7 + player.stats.backAttack * 0.3;
         }
         return score * modifier;

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

@@ -1,8 +1,8 @@
 import { describe, expect, test } from '@jest/globals';
-import { Spike, SpikeFailure, SpikeType } from './spike';
+import { Spike, SpikeFailureEnum, SpikeTypeEnum } from './spike';
 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('Spike Test Module', () => {
     let spike;
@@ -13,43 +13,43 @@ describe('Spike Test Module', () => {
             id: uuidv4(),
             order: 1,
             player: player,
-            target: CourtTarget.OPPONENT_RIGHT_BACK,
-            failure: SpikeFailure.NO_FAILURE,
-            type: SpikeType.CROSS_SHOT,
-            eventType: EventType.SPIKE,
+            target: CourtTargetEnum.OPPONENT_RIGHT_BACK,
+            failure: SpikeFailureEnum.NO_FAILURE,
+            type: SpikeTypeEnum.CROSS_SHOT,
+            eventType: EventTypeEnum.SPIKE,
             modifier: 1,
-            score: Spike.getScore(player, SpikeType.CROSS_SHOT, 1, false)
+            score: Spike.getScore(player, SpikeTypeEnum.CROSS_SHOT, 1, false)
         });
         failed = new Spike({
             id: uuidv4(),
             order: 1,
             player: player,
-            target: CourtTarget.NO_TARGET,
-            failure: SpikeFailure.OUT_OF_BOUNDS,
-            type: SpikeType.TIP,
-            eventType: EventType.SPIKE,
+            target: CourtTargetEnum.NO_TARGET,
+            failure: SpikeFailureEnum.OUT_OF_BOUNDS,
+            type: SpikeTypeEnum.TIP,
+            eventType: EventTypeEnum.SPIKE,
             modifier: 1,
-            score: Spike.getScore(player, SpikeType.TIP, 1, false)
+            score: Spike.getScore(player, SpikeTypeEnum.TIP, 1, false)
         });
         backAttack = new Spike({
             id: uuidv4(),
             order: 1,
             player: player,
-            target: CourtTarget.OPPONENT_RIGHT_BACK,
-            failure: SpikeFailure.NO_FAILURE,
-            type: SpikeType.CROSS_SHOT,
-            eventType: EventType.SPIKE,
+            target: CourtTargetEnum.OPPONENT_RIGHT_BACK,
+            failure: SpikeFailureEnum.NO_FAILURE,
+            type: SpikeTypeEnum.CROSS_SHOT,
+            eventType: EventTypeEnum.SPIKE,
             modifier: 1,
-            score: Spike.getScore(player, SpikeType.CROSS_SHOT, 1, true)
+            score: Spike.getScore(player, SpikeTypeEnum.CROSS_SHOT, 1, true)
         });
     });
     test('Should instantiate object properly', () => {
-        expect(spike.target).toBe(CourtTarget.OPPONENT_RIGHT_BACK);
-        expect(spike.type).toBe(SpikeType.CROSS_SHOT);
-        expect(spike.eventType).toBe(EventType.SPIKE);
+        expect(spike.target).toBe(CourtTargetEnum.OPPONENT_RIGHT_BACK);
+        expect(spike.type).toBe(SpikeTypeEnum.CROSS_SHOT);
+        expect(spike.eventType).toBe(EventTypeEnum.SPIKE);
         expect(spike.player.id).toBe(player.id);
-        expect(spike.failure).toBe(SpikeFailure.NO_FAILURE);
-        expect(failed.failure).toBe(SpikeFailure.OUT_OF_BOUNDS);
+        expect(spike.failure).toBe(SpikeFailureEnum.NO_FAILURE);
+        expect(failed.failure).toBe(SpikeFailureEnum.OUT_OF_BOUNDS);
         expect(spike.modifier).toBe(1);
     });
     // getScore Tests

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

@@ -1,10 +1,9 @@
-import { CourtPosition, CourtRow, CourtTarget, EventStat, Match, MatchRating, MatchSet, MatchSetState, MatchTeam, PlayerPosition, Rally, RallyState, SetStatistics } from './match';
-import { Coach, Formation, SubPriority } from './coach';
-import { Country } from './country';
-import { Draft, DraftPick } from './draft';
-import { Team } from './team';
-import { Block, BlockFailure, BlockType, EventType, InPlayEvent, InPlayEventOpts, LiberoReplacement, LiberoReplacementType, RallyEvent, RallyEventOpts, Reception, ReceptionFailure, ReceptionType, Score, Serve, ServeFailure, ServeType, Set, SetFailure, SetType, Spike, SpikeFailure, SpikeType, Substitution } from './event';
-import { GeneralStat, Name, PerformanceStats, Player, Role, Stat, Trait } from './player';
-import { Iteration, League, Season, Stage, Standing, Tournament, TournamentMatch } from './competition';
-import { formatNumber, generateModifier, getKeys, getRandomEnumValue, randomNumber, shuffle, validateUUID } from './utils';
-export { Draft, DraftPick, Stage, TournamentMatch, Tournament, Block, BlockFailure, BlockType, Coach, Country, CourtPosition, CourtRow, CourtTarget, EventStat, EventType, Formation, formatNumber, GeneralStat, generateModifier, getKeys, getRandomEnumValue, InPlayEvent, InPlayEventOpts, League, LiberoReplacement, LiberoReplacementType, Match, MatchSet, MatchRating, MatchSetState, MatchTeam, Name, PerformanceStats, Player, PlayerPosition, Rally, RallyEvent, RallyEventOpts, RallyState, randomNumber, Reception, ReceptionFailure, ReceptionType, Role, Score, Season, Serve, ServeFailure, ServeType, Set, SetFailure, SetStatistics, SetType, shuffle, Spike, SpikeFailure, SpikeType, Standing, Stat, SubPriority, Substitution, Team, Trait, Iteration, validateUUID };
+export * from './match';
+export * from './coach';
+export * from './country';
+export * from './draft';
+export * from './team';
+export * from './event';
+export * from './player';
+export * from './competition';
+export * from './utils';

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

@@ -1,10 +1,9 @@
-import { CourtPosition, CourtRow, CourtTarget, Match, MatchRating, MatchSet, MatchSetState, MatchTeam, Rally, RallyState, } from './match';
-import { Coach, Formation } from './coach';
-import { Country } from './country';
-import { Draft, DraftPick } from './draft';
-import { Team } from './team';
-import { Block, BlockFailure, BlockType, EventType, InPlayEvent, LiberoReplacement, LiberoReplacementType, RallyEvent, Reception, ReceptionFailure, ReceptionType, Score, Serve, ServeFailure, ServeType, Set, SetFailure, SetType, Spike, SpikeFailure, SpikeType, Substitution } from './event';
-import { GeneralStat, PerformanceStats, Player, Role, Trait } from './player';
-import { Iteration, League, Season, Stage, Standing, Tournament, TournamentMatch } from './competition';
-import { formatNumber, generateModifier, getKeys, getRandomEnumValue, randomNumber, shuffle, validateUUID, } from './utils';
-export { Draft, DraftPick, Stage, TournamentMatch, Tournament, Block, BlockFailure, BlockType, Coach, Country, CourtPosition, CourtRow, CourtTarget, EventType, Formation, formatNumber, GeneralStat, generateModifier, getKeys, getRandomEnumValue, InPlayEvent, League, LiberoReplacement, LiberoReplacementType, Match, MatchSet, MatchRating, MatchSetState, MatchTeam, PerformanceStats, Player, Rally, RallyEvent, RallyState, randomNumber, Reception, ReceptionFailure, ReceptionType, Role, Score, Season, Serve, ServeFailure, ServeType, Set, SetFailure, SetType, shuffle, Spike, SpikeFailure, SpikeType, Standing, Substitution, Team, Trait, Iteration, validateUUID };
+export * from './match';
+export * from './coach';
+export * from './country';
+export * from './draft';
+export * from './team';
+export * from './event';
+export * from './player';
+export * from './competition';
+export * from './utils';

package/dist/esm/src/service/match/{court-target.d.ts → court-target-enum.d.ts}

@@ -1,5 +1,5 @@
 import { CourtPosition } from './court-position';
-export declare enum CourtTarget {
+export declare enum CourtTargetEnum {
     NO_TARGET = 0,
     OPPONENT_RIGHT_BACK = 7,
     OPPONENT_MIDDLE_BACK = 12,
@@ -14,8 +14,8 @@ export declare enum CourtTarget {
     TEAM_MIDDLE_BACK = 6,
     TEAM_RIGHT_BACK = 1
 }
-export declare namespace CourtTarget {
-    function getTeamSide(): CourtTarget[];
-    function getOpponentSide(): CourtTarget[];
+export declare namespace CourtTargetEnum {
+    function getTeamSide(): CourtTargetEnum[];
+    function getOpponentSide(): CourtTargetEnum[];
     function getSidePosition(position: number): CourtPosition;
 }

package/dist/esm/src/service/match/court-target-enum.js

@@ -0,0 +1,39 @@
+export var CourtTargetEnum;
+(function (CourtTargetEnum) {
+    CourtTargetEnum[CourtTargetEnum["NO_TARGET"] = 0] = "NO_TARGET";
+    CourtTargetEnum[CourtTargetEnum["OPPONENT_RIGHT_BACK"] = 7] = "OPPONENT_RIGHT_BACK";
+    CourtTargetEnum[CourtTargetEnum["OPPONENT_MIDDLE_BACK"] = 12] = "OPPONENT_MIDDLE_BACK";
+    CourtTargetEnum[CourtTargetEnum["OPPONENT_LEFT_BACK"] = 11] = "OPPONENT_LEFT_BACK";
+    CourtTargetEnum[CourtTargetEnum["OPPONENT_RIGHT_FRONT"] = 8] = "OPPONENT_RIGHT_FRONT";
+    CourtTargetEnum[CourtTargetEnum["OPPONENT_MIDDLE_FRONT"] = 9] = "OPPONENT_MIDDLE_FRONT";
+    CourtTargetEnum[CourtTargetEnum["OPPONENT_LEFT_FRONT"] = 10] = "OPPONENT_LEFT_FRONT";
+    // --------------------------------------------------------------------------------
+    CourtTargetEnum[CourtTargetEnum["TEAM_LEFT_FRONT"] = 4] = "TEAM_LEFT_FRONT";
+    CourtTargetEnum[CourtTargetEnum["TEAM_MIDDLE_FRONT"] = 3] = "TEAM_MIDDLE_FRONT";
+    CourtTargetEnum[CourtTargetEnum["TEAM_RIGHT_FRONT"] = 2] = "TEAM_RIGHT_FRONT";
+    CourtTargetEnum[CourtTargetEnum["TEAM_LEFT_BACK"] = 5] = "TEAM_LEFT_BACK";
+    CourtTargetEnum[CourtTargetEnum["TEAM_MIDDLE_BACK"] = 6] = "TEAM_MIDDLE_BACK";
+    CourtTargetEnum[CourtTargetEnum["TEAM_RIGHT_BACK"] = 1] = "TEAM_RIGHT_BACK";
+})(CourtTargetEnum || (CourtTargetEnum = {}));
+// eslint-disable-next-line @typescript-eslint/no-namespace
+(function (CourtTargetEnum) {
+    function getTeamSide() {
+        return [CourtTargetEnum.TEAM_RIGHT_BACK, CourtTargetEnum.TEAM_RIGHT_FRONT, CourtTargetEnum.TEAM_MIDDLE_FRONT,
+            CourtTargetEnum.TEAM_LEFT_FRONT, CourtTargetEnum.TEAM_LEFT_BACK, CourtTargetEnum.TEAM_MIDDLE_BACK];
+    }
+    CourtTargetEnum.getTeamSide = getTeamSide;
+    function getOpponentSide() {
+        return [CourtTargetEnum.OPPONENT_RIGHT_BACK, CourtTargetEnum.OPPONENT_RIGHT_FRONT, CourtTargetEnum.OPPONENT_MIDDLE_FRONT,
+            CourtTargetEnum.OPPONENT_LEFT_FRONT, CourtTargetEnum.OPPONENT_LEFT_BACK, CourtTargetEnum.OPPONENT_MIDDLE_BACK];
+    }
+    CourtTargetEnum.getOpponentSide = getOpponentSide;
+    function getSidePosition(position) {
+        if (position < 1 || position > 12)
+            throw new Error('POSITION_INDEX_OUT_OF_BOUNDS');
+        if (position > 6)
+            return position - 6;
+        else
+            return position;
+    }
+    CourtTargetEnum.getSidePosition = getSidePosition;
+})(CourtTargetEnum || (CourtTargetEnum = {}));