volleyballsimtypes 0.0.75 → 0.0.77

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

@@ -1,23 +1,23 @@
 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 });
+    constructor({ id, order, score, player, target, failure, type, modifier, eventType, blockers, activeTraits }) {
+        super({ id, order, score, player, target, modifier, eventType, activeTraits });
         this.type = type;
         this.failure = failure;
         this.blockers = blockers;
@@ -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,70 +15,75 @@ 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)
+            score: Block.getScore([], 1),
+            activeTraits: []
         });
         block = new Block({
             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)
+            score: Block.getScore([player], 1),
+            activeTraits: []
         });
         double = new Block({
             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)
+            score: Block.getScore([player, player], 1),
+            activeTraits: []
         });
         triple = new Block({
             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)
+            score: Block.getScore([player, player, player], 1),
+            activeTraits: []
         });
         failed = new Block({
             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)
+            score: Block.getScore([player], 1),
+            activeTraits: []
         });
     });
     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,17 +1,19 @@
 import { RallyEvent, RallyEventOpts } from './rally-event';
-import { CourtTarget } from '../match';
-import { PerformanceStats } from '../player';
+import { CourtTargetEnum } from '../match';
+import { PerformanceStats, Trait } from '../player';
 export interface InPlayEventOpts extends RallyEventOpts {
-    readonly target: CourtTarget;
+    readonly target: CourtTargetEnum;
     readonly modifier: number;
     readonly score: number;
+    readonly activeTraits: Trait[];
 }
 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);
+    readonly activeTraits: Trait[];
+    protected constructor({ id, eventType, player, target, modifier, score, order, activeTraits }: InPlayEventOpts);
     protected static calculateScore(stats: PerformanceStats, eventType: string, type: string): number;
 }

package/dist/esm/src/service/event/in-play-event.js

@@ -2,11 +2,12 @@ import { RallyEvent } from './rally-event';
 import formula from '../../../data/event.formula.json';
 import { getKeys } from '../utils';
 export class InPlayEvent extends RallyEvent {
-    constructor(opts) {
-        super(opts);
-        this.target = opts.target;
-        this.score = opts.score;
-        this.modifier = opts.modifier;
+    constructor({ id, eventType, player, target, modifier, score, order, activeTraits }) {
+        super({ id, order, player, eventType });
+        this.target = target;
+        this.score = score;
+        this.modifier = modifier;
+        this.activeTraits = activeTraits;
     }
     static calculateScore(stats, eventType, type) {
         const weight = formula[eventType][type];

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

@@ -3,15 +3,15 @@ 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);
+    constructor({ id, order, player, type, libero, eventType }: LiberoReplacementOpts);
 }
 export {};

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 { 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 });
+    constructor({ id, order, player, type, libero, eventType }) {
+        super({ id, order, player, eventType });
         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;
-    constructor({ id, order, score, player, target, failure, type, eventType, modifier }: ReceptionOpts);
-    static getScore(stats: PerformanceStats, type: ReceptionType, modifier: number): number;
+    readonly failure: ReceptionFailureEnum;
+    readonly type: ReceptionTypeEnum;
+    constructor({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }: ReceptionOpts);
+    static getScore(stats: PerformanceStats, type: ReceptionTypeEnum, modifier: number): number;
 }
 export {};

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

@@ -1,26 +1,26 @@
 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 });
+    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 Reception.calculateScore(stats, 'RECEPTION', ReceptionType[type]) * modifier;
+        return Reception.calculateScore(stats, 'RECEPTION', ReceptionTypeEnum[type]) * modifier;
     }
 }

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,31 +12,33 @@ 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,
-            modifier: 1
+            target: CourtTargetEnum.OPPONENT_RIGHT_BACK,
+            failure: ReceptionFailureEnum.NO_FAILURE,
+            type: ReceptionTypeEnum.DIG,
+            eventType: EventTypeEnum.RECEPTION,
+            modifier: 1,
+            activeTraits: []
         });
         failed = new Reception({
             score: 60,
             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,
-            modifier: 1
+            target: CourtTargetEnum.NO_TARGET,
+            failure: ReceptionFailureEnum.OUT_OF_BOUNDS,
+            type: ReceptionTypeEnum.OTHER_BODY_PART,
+            eventType: EventTypeEnum.RECEPTION,
+            modifier: 1,
+            activeTraits: []
         });
     });
     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;
-    constructor({ id, order, score, player, target, failure, type, eventType, modifier }: ServeOpts);
-    static getScore(stats: PerformanceStats, type: ServeType, modifier: number): number;
+    readonly failure: ServeFailureEnum;
+    readonly type: ServeTypeEnum;
+    constructor({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }: ServeOpts);
+    static getScore(stats: PerformanceStats, type: ServeTypeEnum, modifier: number): number;
 }
 export {};

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

@@ -1,27 +1,27 @@
 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 });
+    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 Serve.calculateScore(stats, 'SERVE', ServeType[type]) * modifier;
+        return Serve.calculateScore(stats, 'SERVE', ServeTypeEnum[type]) * modifier;
     }
 }