volleyballsimtypes 0.0.75 → 0.0.77

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,31 +12,33 @@ 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,
-            modifier: 1
+            target: CourtTargetEnum.OPPONENT_RIGHT_BACK,
+            failure: ServeFailureEnum.NO_FAILURE,
+            type: ServeTypeEnum.JUMP_TOPSPIN,
+            eventType: EventTypeEnum.SERVE,
+            modifier: 1,
+            activeTraits: []
         });
         failed = new Serve({
             score: 60,
             id: '622c36dc-f2d2-44b3-a744-667ea53218b7',
             order: 0,
             player: player,
-            target: CourtTarget.NO_TARGET,
-            failure: ServeFailure.NET,
-            type: ServeType.UNDERHAND,
-            eventType: EventType.SERVE,
-            modifier: 1
+            target: CourtTargetEnum.NO_TARGET,
+            failure: ServeFailureEnum.NET,
+            type: ServeTypeEnum.UNDERHAND,
+            eventType: EventTypeEnum.SERVE,
+            modifier: 1,
+            activeTraits: []
         });
     });
     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;
-    constructor({ id, order, score, player, target, failure, type, eventType, modifier }: SetOpts);
-    static getScore(stats: PerformanceStats, type: SetType, modifier: number): number;
+    readonly failure: SetFailureEnum;
+    readonly type: SetTypeEnum;
+    constructor({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }: SetOpts);
+    static getScore(stats: PerformanceStats, type: SetTypeEnum, modifier: number): number;
 }
 export {};

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

@@ -1,26 +1,26 @@
 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 });
+    constructor({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }) {
+        super({ id, order, score, player, target, eventType, modifier, activeTraits });
         this.type = type;
         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,31 +12,33 @@ 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,
-            modifier: 1
+            target: CourtTargetEnum.OPPONENT_RIGHT_BACK,
+            failure: SetFailureEnum.NO_FAILURE,
+            type: SetTypeEnum.OVERHAND,
+            eventType: EventTypeEnum.SET,
+            modifier: 1,
+            activeTraits: []
         });
         failed = new Set({
             score: 60,
             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,
-            modifier: 1
+            target: CourtTargetEnum.NO_TARGET,
+            failure: SetFailureEnum.OUT_OF_BOUNDS,
+            type: SetTypeEnum.DUMP,
+            eventType: EventTypeEnum.SET,
+            modifier: 1,
+            activeTraits: []
         });
     });
     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;
-    constructor({ id, order, score, player, target, failure, type, eventType, modifier }: SpikeOpts);
-    static getScore(player: Player, type: SpikeType, modifier: number, isBackRow: boolean): number;
+    readonly failure: SpikeFailureEnum;
+    readonly type: SpikeTypeEnum;
+    constructor({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }: SpikeOpts);
+    static getScore(player: Player, type: SpikeTypeEnum, modifier: number, isBackRow: boolean): number;
 }
 export {};

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

@@ -1,30 +1,30 @@
 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 });
+    constructor({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }) {
+        super({ id, order, score, player, target, eventType, modifier, activeTraits });
         this.type = type;
         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,46 @@ 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),
+            activeTraits: []
         });
         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),
+            activeTraits: []
         });
         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),
+            activeTraits: []
         });
     });
     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/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 = {}));

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

@@ -1,35 +1,35 @@
 import { describe, expect, test } from '@jest/globals';
-import { CourtTarget } from './court-target';
+import { CourtTargetEnum } from './court-target-enum';
 describe('CourtTarget Test Module', () => {
     // getSidePosition Tests
     test('Should get correct court position', () => {
         for (let i = 1; i < 7; i++) {
-            expect(CourtTarget.getSidePosition(i)).toBe(i);
-            expect(CourtTarget.getSidePosition(i + 6)).toBe(i);
+            expect(CourtTargetEnum.getSidePosition(i)).toBe(i);
+            expect(CourtTargetEnum.getSidePosition(i + 6)).toBe(i);
         }
     });
     test('Should throw Error when position is out of bounds', () => {
-        function position() { CourtTarget.getSidePosition(0); }
+        function position() { CourtTargetEnum.getSidePosition(0); }
         expect(position).toThrow(/^POSITION_INDEX_OUT_OF_BOUNDS$/);
     });
     // getTeamSide Tests
     test('Should return team positions', () => {
-        const positions = CourtTarget.getTeamSide();
-        expect(positions[0]).toBe(CourtTarget.TEAM_RIGHT_BACK);
-        expect(positions[1]).toBe(CourtTarget.TEAM_RIGHT_FRONT);
-        expect(positions[2]).toBe(CourtTarget.TEAM_MIDDLE_FRONT);
-        expect(positions[3]).toBe(CourtTarget.TEAM_LEFT_FRONT);
-        expect(positions[4]).toBe(CourtTarget.TEAM_LEFT_BACK);
-        expect(positions[5]).toBe(CourtTarget.TEAM_MIDDLE_BACK);
+        const positions = CourtTargetEnum.getTeamSide();
+        expect(positions[0]).toBe(CourtTargetEnum.TEAM_RIGHT_BACK);
+        expect(positions[1]).toBe(CourtTargetEnum.TEAM_RIGHT_FRONT);
+        expect(positions[2]).toBe(CourtTargetEnum.TEAM_MIDDLE_FRONT);
+        expect(positions[3]).toBe(CourtTargetEnum.TEAM_LEFT_FRONT);
+        expect(positions[4]).toBe(CourtTargetEnum.TEAM_LEFT_BACK);
+        expect(positions[5]).toBe(CourtTargetEnum.TEAM_MIDDLE_BACK);
     });
     // getOpponentSide Tests
     test('Should return opponent team positions', () => {
-        const positions = CourtTarget.getOpponentSide();
-        expect(positions[0]).toBe(CourtTarget.OPPONENT_RIGHT_BACK);
-        expect(positions[1]).toBe(CourtTarget.OPPONENT_RIGHT_FRONT);
-        expect(positions[2]).toBe(CourtTarget.OPPONENT_MIDDLE_FRONT);
-        expect(positions[3]).toBe(CourtTarget.OPPONENT_LEFT_FRONT);
-        expect(positions[4]).toBe(CourtTarget.OPPONENT_LEFT_BACK);
-        expect(positions[5]).toBe(CourtTarget.OPPONENT_MIDDLE_BACK);
+        const positions = CourtTargetEnum.getOpponentSide();
+        expect(positions[0]).toBe(CourtTargetEnum.OPPONENT_RIGHT_BACK);
+        expect(positions[1]).toBe(CourtTargetEnum.OPPONENT_RIGHT_FRONT);
+        expect(positions[2]).toBe(CourtTargetEnum.OPPONENT_MIDDLE_FRONT);
+        expect(positions[3]).toBe(CourtTargetEnum.OPPONENT_LEFT_FRONT);
+        expect(positions[4]).toBe(CourtTargetEnum.OPPONENT_LEFT_BACK);
+        expect(positions[5]).toBe(CourtTargetEnum.OPPONENT_MIDDLE_BACK);
     });
 });

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

@@ -3,5 +3,5 @@ export * from './match-rating';
 export * from './match-set';
 export * from './rally';
 export * from './court-position';
-export * from './court-target';
+export * from './court-target-enum';
 export * from './match-team';

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

@@ -3,5 +3,5 @@ export * from './match-rating';
 export * from './match-set';
 export * from './rally';
 export * from './court-position';
-export * from './court-target';
+export * from './court-target-enum';
 export * from './match-team';

package/dist/esm/src/service/match/rally.js

@@ -1,5 +1,5 @@
 import { validateUUID } from '../utils';
-import { EventType } from '../event/rally-event';
+import { EventTypeEnum } from '../event/rally-event';
 export var RallyState;
 (function (RallyState) {
     RallyState[RallyState["NEW"] = 0] = "NEW";
@@ -33,7 +33,7 @@ export class Rally {
         return this._state;
     }
     get score() {
-        return this.events.find(e => e.eventType === EventType.SCORE);
+        return this.events.find(e => e.eventType === EventTypeEnum.SCORE);
     }
     isOver() {
         return this._state === RallyState.FINISHED;

package/dist/esm/src/service/match/rally.test.js

@@ -1,7 +1,7 @@
 import { describe, expect, test } from '@jest/globals';
 import { Rally, RallyState } from './rally';
 import { score, serve } from '../event/__stubs__';
-import { EventType } from '../event/rally-event';
+import { EventTypeEnum } from '../event/rally-event';
 import { team } from '../team/__stubs__';
 describe('Rally Test Module', () => {
     let rally;
@@ -44,7 +44,7 @@ describe('Rally Test Module', () => {
     test('Should add event to event array', () => {
         expect(rally.events.length).toBe(0);
         rally.addEvent(serve);
-        expect(rally.events.at(-1)?.eventType).toBe(EventType.SERVE);
+        expect(rally.events.at(-1)?.eventType).toBe(EventTypeEnum.SERVE);
     });
     // isOver Tests
     test('Should return false if rally state is not FINISHED', () => {
@@ -66,7 +66,7 @@ describe('Rally Test Module', () => {
     test('Should return Score if events array contains a Score', () => {
         rally.addEvent(score);
         expect(rally.score).not.toBeUndefined();
-        expect(rally.score?.eventType).toBe(EventType.SCORE);
+        expect(rally.score?.eventType).toBe(EventTypeEnum.SCORE);
     });
     // RallyState Tests
     test('Should get next state', () => {

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

@@ -1,6 +1,5 @@
 import { PerformanceStats } from './performance-stats';
 export declare class Role {
-    readonly name: string;
     static readonly SETTER: Role;
     static readonly LIBERO: Role;
     static readonly OUTSIDE_HITTER: Role;
@@ -8,6 +7,7 @@ export declare class Role {
     static readonly MIDDLE_BLOCKER: Role;
     static readonly DEFENSIVE_SPECIALIST: Role;
     private static readonly ROLES;
+    readonly name: string;
     private constructor();
     static getRoles(): Role[];
     static calculateScore(stats: PerformanceStats, role: Role): number;

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

@@ -20,12 +20,12 @@ export declare class Team {
     readonly coach?: Coach;
     readonly league?: League;
     readonly country?: Country;
-    private _rating;
     constructor({ id, rating, name, shortName, country, roster, coach, league }: TeamOpts);
-    isPlayerInRoster(player: Player): boolean;
-    toString(): string;
+    private _rating;
     get rating(): number;
     set rating(value: number);
+    isPlayerInRoster(player: Player): boolean;
+    toString(): string;
     updateRating(ratingChange: number): void;
 }
 export {};

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

@@ -12,18 +12,18 @@ export class Team {
         this.country = country;
         this.league = league;
     }
-    isPlayerInRoster(player) {
-        return this.roster.some(p => p.id === player.id);
-    }
-    toString() {
-        return `${this.name} [${this.shortName}] (${this.country?.name}) ELO=${this._rating}`;
-    }
     get rating() {
         return this._rating;
     }
     set rating(value) {
         this._rating = value;
     }
+    isPlayerInRoster(player) {
+        return this.roster.some(p => p.id === player.id);
+    }
+    toString() {
+        return `${this.name} [${this.shortName}] (${this.country?.name}) ELO=${this._rating}`;
+    }
     updateRating(ratingChange) {
         if (Math.abs(ratingChange) > MatchRating.K)
             throw new Error(`INVALID RATING CHANGE: ${ratingChange}`);

package/package.json

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