volleyballsimtypes 0.0.125 → 0.0.126

package/dist/cjs/src/data/transformers/rally.js

@@ -36,42 +36,35 @@ function transformToAttributes(rally, setId) {
 exports.transformFromRally = transformToAttributes;
 function transformToObject(model) {
     const decompressed = JSON.parse((0, lz_string_1.decompressFromBase64)(model.events));
-    const liberoReplacements = [];
-    const substitutions = [];
-    const serves = [];
-    const receptions = [];
-    const sets = [];
-    const spikes = [];
-    const blocks = [];
+    const events = [];
     decompressed.forEach(event => {
         switch (event.event_type) {
             case 0:
-                liberoReplacements.push(event);
+                events.push(event);
                 break;
             case 1:
-                substitutions.push(event);
+                events.push(event);
                 break;
             case 2:
-                serves.push(event);
+                events.push(event);
                 break;
             case 3:
-                receptions.push(event);
+                events.push(event);
                 break;
             case 4:
-                sets.push(event);
+                events.push(event);
                 break;
             case 5:
-                spikes.push(event);
+                events.push(event);
                 break;
             case 6:
-                blocks.push(event);
+                events.push(event);
                 break;
             default:
                 throw new Error('UNKNOWN_EVENT');
         }
+        events.push(event);
     });
-    const events = [...liberoReplacements, ...substitutions, ...serves, ...receptions, ...sets, ...spikes, ...blocks]
-        .sort((e1, e2) => e1.order - e2.order);
     return new service_1.Rally({
         id: model.rally_id,
         order: model.order,
@@ -82,42 +75,34 @@ function transformToObject(model) {
 exports.transformToRally = transformToObject;
 function transformToAPIObject(model) {
     const decompressed = JSON.parse((0, lz_string_1.decompressFromBase64)(model.events));
-    const liberoReplacements = [];
-    const substitutions = [];
-    const serves = [];
-    const receptions = [];
-    const sets = [];
-    const spikes = [];
-    const blocks = [];
+    const events = [];
     decompressed.forEach(event => {
         switch (event.event_type) {
             case 0:
-                liberoReplacements.push((0, _1.transformToAPILiberoReplacement)(event));
+                events.push((0, _1.transformToAPILiberoReplacement)(event));
                 break;
             case 1:
-                substitutions.push((0, _1.transformToAPISubstitution)(event));
+                events.push((0, _1.transformToAPISubstitution)(event));
                 break;
             case 2:
-                serves.push((0, _1.transformToAPIServe)(event));
+                events.push((0, _1.transformToAPIServe)(event));
                 break;
             case 3:
-                receptions.push((0, _1.transformToAPIReception)(event));
+                events.push((0, _1.transformToAPIReception)(event));
                 break;
             case 4:
-                sets.push((0, _1.transformToAPISet)(event));
+                events.push((0, _1.transformToAPISet)(event));
                 break;
             case 5:
-                spikes.push((0, _1.transformToAPISpike)(event));
+                events.push((0, _1.transformToAPISpike)(event));
                 break;
             case 6:
-                blocks.push((0, _1.transformToAPIBlock)(event));
+                events.push((0, _1.transformToAPIBlock)(event));
                 break;
             default:
                 throw new Error('UNKNOWN_EVENT');
         }
     });
-    const events = [...liberoReplacements, ...substitutions, ...serves, ...receptions, ...sets, ...spikes, ...blocks]
-        .sort((e1, e2) => e1.order - e2.order);
     return {
         id: model.rally_id,
         order: model.order,

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

@@ -23,7 +23,7 @@ export declare class Block extends InPlayEvent {
     readonly failure: BlockFailureEnum;
     readonly type: BlockTypeEnum;
     readonly blockers: string[];
-    constructor({ order, score, player, target, failure, type, modifier, eventType, blockers, activeTraits }: BlockOpts);
+    constructor({ score, player, target, failure, type, modifier, eventType, blockers, activeTraits }: BlockOpts);
     static getScore(blockers: Player[], modifier: number, activeTraits: Trait[]): number;
     toString(): string;
 }

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

@@ -20,8 +20,8 @@ var BlockTypeEnum;
     BlockTypeEnum[BlockTypeEnum["TRIPLE"] = 3] = "TRIPLE";
 })(BlockTypeEnum = exports.BlockTypeEnum || (exports.BlockTypeEnum = {}));
 class Block extends in_play_event_1.InPlayEvent {
-    constructor({ order, score, player, target, failure, type, modifier, eventType, blockers, activeTraits }) {
-        super({ order, score, player, target, modifier, eventType, activeTraits });
+    constructor({ score, player, target, failure, type, modifier, eventType, blockers, activeTraits }) {
+        super({ score, player, target, modifier, eventType, activeTraits });
         this.type = type;
         this.failure = failure;
         this.blockers = blockers.map(b => b.id);
@@ -62,7 +62,7 @@ class Block extends in_play_event_1.InPlayEvent {
         return score;
     }
     toString() {
-        return `{order:${this.order},score:${this.order},player:${this.player},target:${this.target},failure:${this.failure},type:${this.type},modifier:${this.modifier},eventType:${this.eventType},blockers:[${this.blockers.join(',')}],activeTraits:[${this.activeTraits.join(',')}]}`;
+        return `{score:${this.score},player:${this.player},target:${this.target},failure:${this.failure},type:${this.type},modifier:${this.modifier},eventType:${this.eventType},blockers:[${this.blockers.join(',')}],activeTraits:[${this.activeTraits.join(',')}]}`;
     }
 }
 exports.Block = Block;

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

@@ -14,6 +14,6 @@ export declare abstract class InPlayEvent extends RallyEvent {
     readonly modifier: number;
     readonly score: number;
     readonly activeTraits: string[];
-    protected constructor({ eventType, player, target, modifier, score, order, activeTraits }: InPlayEventOpts);
+    protected constructor({ eventType, player, target, modifier, score, activeTraits }: InPlayEventOpts);
     protected static calculateScore(stats: PerformanceStats, eventType: string, type: string): number;
 }

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

@@ -8,8 +8,8 @@ const rally_event_1 = require("./rally-event");
 const event_formula_json_1 = __importDefault(require("../../../data/event.formula.json"));
 const utils_1 = require("../utils");
 class InPlayEvent extends rally_event_1.RallyEvent {
-    constructor({ eventType, player, target, modifier, score, order, activeTraits }) {
-        super({ order, player, eventType });
+    constructor({ eventType, player, target, modifier, score, activeTraits }) {
+        super({ player, eventType });
         this.target = target;
         this.score = score;
         this.modifier = modifier;

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

@@ -12,7 +12,7 @@ export declare enum LiberoReplacementTypeEnum {
 export declare class LiberoReplacement extends RallyEvent {
     readonly type: LiberoReplacementTypeEnum;
     readonly libero: string;
-    constructor({ order, player, type, libero, eventType }: LiberoReplacementOpts);
+    constructor({ player, type, libero, eventType }: LiberoReplacementOpts);
     toString(): string;
 }
 export {};

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

@@ -8,13 +8,13 @@ var LiberoReplacementTypeEnum;
     LiberoReplacementTypeEnum[LiberoReplacementTypeEnum["LIBERO_OUT"] = 1] = "LIBERO_OUT";
 })(LiberoReplacementTypeEnum = exports.LiberoReplacementTypeEnum || (exports.LiberoReplacementTypeEnum = {}));
 class LiberoReplacement extends rally_event_1.RallyEvent {
-    constructor({ order, player, type, libero, eventType }) {
-        super({ order, player, eventType });
+    constructor({ player, type, libero, eventType }) {
+        super({ player, eventType });
         this.type = type;
         this.libero = libero.id;
     }
     toString() {
-        return `{order:${this.order},player:${this.player},type:${this.type},eventType:${this.eventType},libero:${this.libero}}`;
+        return `{player:${this.player},type:${this.type},eventType:${this.eventType},libero:${this.libero}}`;
     }
 }
 exports.LiberoReplacement = LiberoReplacement;

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

@@ -11,11 +11,9 @@ export declare enum EventTypeEnum {
 export interface RallyEventOpts {
     readonly player: Player;
     readonly eventType: EventTypeEnum;
-    readonly order: number;
 }
 export declare abstract class RallyEvent {
-    readonly order: number;
     readonly player: string;
     readonly eventType: EventTypeEnum;
-    protected constructor({ eventType, player, order }: RallyEventOpts);
+    protected constructor({ eventType, player }: RallyEventOpts);
 }

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

@@ -12,9 +12,8 @@ var EventTypeEnum;
     EventTypeEnum[EventTypeEnum["BLOCK"] = 6] = "BLOCK";
 })(EventTypeEnum = exports.EventTypeEnum || (exports.EventTypeEnum = {}));
 class RallyEvent {
-    constructor({ eventType, player, order }) {
+    constructor({ eventType, player }) {
         this.player = player.id;
-        this.order = order;
         this.eventType = eventType;
     }
 }

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

@@ -20,7 +20,7 @@ interface ReceptionOpts extends InPlayEventOpts {
 export declare class Reception extends InPlayEvent {
     readonly failure: ReceptionFailureEnum;
     readonly type: ReceptionTypeEnum;
-    constructor({ order, score, player, target, failure, type, eventType, modifier, activeTraits }: ReceptionOpts);
+    constructor({ score, player, target, failure, type, eventType, modifier, activeTraits }: ReceptionOpts);
     static getScore(stats: PerformanceStats, type: ReceptionTypeEnum, modifier: number, activeTraits: Trait[]): number;
     toString(): string;
 }

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

@@ -19,8 +19,8 @@ var ReceptionFailureEnum;
     ReceptionFailureEnum[ReceptionFailureEnum["BAD_PASS"] = 4] = "BAD_PASS";
 })(ReceptionFailureEnum = exports.ReceptionFailureEnum || (exports.ReceptionFailureEnum = {}));
 class Reception extends in_play_event_1.InPlayEvent {
-    constructor({ order, score, player, target, failure, type, eventType, modifier, activeTraits }) {
-        super({ order, score, player, target, eventType, modifier, activeTraits });
+    constructor({ score, player, target, failure, type, eventType, modifier, activeTraits }) {
+        super({ score, player, target, eventType, modifier, activeTraits });
         this.type = type;
         this.failure = failure;
     }
@@ -37,7 +37,7 @@ class Reception extends in_play_event_1.InPlayEvent {
         return score;
     }
     toString() {
-        return `{order:${this.order},score:${this.order},player:${this.player},target:${this.target},failure:${this.failure},type:${this.type},modifier:${this.modifier},eventType:${this.eventType},activeTraits:[${this.activeTraits.join(',')}]}`;
+        return `{score:${this.score},player:${this.player},target:${this.target},failure:${this.failure},type:${this.type},modifier:${this.modifier},eventType:${this.eventType},activeTraits:[${this.activeTraits.join(',')}]}`;
     }
 }
 exports.Reception = Reception;

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

@@ -21,7 +21,7 @@ interface ServeOpts extends InPlayEventOpts {
 export declare class Serve extends InPlayEvent {
     readonly failure: ServeFailureEnum;
     readonly type: ServeTypeEnum;
-    constructor({ order, score, player, target, failure, type, eventType, modifier, activeTraits }: ServeOpts);
+    constructor({ score, player, target, failure, type, eventType, modifier, activeTraits }: ServeOpts);
     static getScore(stats: PerformanceStats, type: ServeTypeEnum, modifier: number, activeTraits: Trait[]): number;
     toString(): string;
 }

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

@@ -19,8 +19,8 @@ var ServeFailureEnum;
     ServeFailureEnum[ServeFailureEnum["OUT_OF_BOUNDS"] = 4] = "OUT_OF_BOUNDS";
 })(ServeFailureEnum = exports.ServeFailureEnum || (exports.ServeFailureEnum = {}));
 class Serve extends in_play_event_1.InPlayEvent {
-    constructor({ order, score, player, target, failure, type, eventType, modifier, activeTraits }) {
-        super({ order, score, player, target, eventType, modifier, activeTraits });
+    constructor({ score, player, target, failure, type, eventType, modifier, activeTraits }) {
+        super({ score, player, target, eventType, modifier, activeTraits });
         this.type = type;
         this.failure = failure;
     }
@@ -32,7 +32,7 @@ class Serve extends in_play_event_1.InPlayEvent {
         return score;
     }
     toString() {
-        return `{order:${this.order},score:${this.order},player:${this.player},target:${this.target},failure:${this.failure},type:${this.type},modifier:${this.modifier},eventType:${this.eventType},activeTraits:[${this.activeTraits.join(',')}]}`;
+        return `{score:${this.score},player:${this.player},target:${this.target},failure:${this.failure},type:${this.type},modifier:${this.modifier},eventType:${this.eventType},activeTraits:[${this.activeTraits.join(',')}]}`;
     }
 }
 exports.Serve = Serve;

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

@@ -20,7 +20,7 @@ interface SetOpts extends InPlayEventOpts {
 export declare class Set extends InPlayEvent {
     readonly failure: SetFailureEnum;
     readonly type: SetTypeEnum;
-    constructor({ order, score, player, target, failure, type, eventType, modifier, activeTraits }: SetOpts);
+    constructor({ score, player, target, failure, type, eventType, modifier, activeTraits }: SetOpts);
     static getScore(stats: PerformanceStats, type: SetTypeEnum, modifier: number, activeTraits: Trait[]): number;
     toString(): string;
 }

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

@@ -19,8 +19,8 @@ var SetFailureEnum;
     SetFailureEnum[SetFailureEnum["OUT_OF_BOUNDS"] = 4] = "OUT_OF_BOUNDS";
 })(SetFailureEnum = exports.SetFailureEnum || (exports.SetFailureEnum = {}));
 class Set extends in_play_event_1.InPlayEvent {
-    constructor({ order, score, player, target, failure, type, eventType, modifier, activeTraits }) {
-        super({ order, score, player, target, eventType, modifier, activeTraits });
+    constructor({ score, player, target, failure, type, eventType, modifier, activeTraits }) {
+        super({ score, player, target, eventType, modifier, activeTraits });
         this.type = type;
         this.failure = failure;
     }
@@ -42,7 +42,7 @@ class Set extends in_play_event_1.InPlayEvent {
         return score;
     }
     toString() {
-        return `{order:${this.order},score:${this.order},player:${this.player},target:${this.target},failure:${this.failure},type:${this.type},modifier:${this.modifier},eventType:${this.eventType},activeTraits:[${this.activeTraits.join(',')}]}`;
+        return `{score:${this.score},player:${this.player},target:${this.target},failure:${this.failure},type:${this.type},modifier:${this.modifier},eventType:${this.eventType},activeTraits:[${this.activeTraits.join(',')}]}`;
     }
 }
 exports.Set = Set;

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

@@ -22,7 +22,7 @@ interface SpikeOpts extends InPlayEventOpts {
 export declare class Spike extends InPlayEvent {
     readonly failure: SpikeFailureEnum;
     readonly type: SpikeTypeEnum;
-    constructor({ order, score, player, target, failure, type, eventType, modifier, activeTraits }: SpikeOpts);
+    constructor({ score, player, target, failure, type, eventType, modifier, activeTraits }: SpikeOpts);
     static getScore(player: Player, type: SpikeTypeEnum, modifier: number, isBackRow: boolean, activeTraits: Trait[]): number;
     toString(): string;
 }

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

@@ -21,8 +21,8 @@ var SpikeFailureEnum;
     SpikeFailureEnum[SpikeFailureEnum["NET"] = 4] = "NET";
 })(SpikeFailureEnum = exports.SpikeFailureEnum || (exports.SpikeFailureEnum = {}));
 class Spike extends in_play_event_1.InPlayEvent {
-    constructor({ order, score, player, target, failure, type, eventType, modifier, activeTraits }) {
-        super({ order, score, player, target, eventType, modifier, activeTraits });
+    constructor({ score, player, target, failure, type, eventType, modifier, activeTraits }) {
+        super({ score, player, target, eventType, modifier, activeTraits });
         this.type = type;
         this.failure = failure;
     }
@@ -47,7 +47,7 @@ class Spike extends in_play_event_1.InPlayEvent {
         return score;
     }
     toString() {
-        return `{order:${this.order},score:${this.order},player:${this.player},target:${this.target},failure:${this.failure},type:${this.type},modifier:${this.modifier},eventType:${this.eventType},activeTraits:[${this.activeTraits.join(',')}]}`;
+        return `{score:${this.score},player:${this.player},target:${this.target},failure:${this.failure},type:${this.type},modifier:${this.modifier},eventType:${this.eventType},activeTraits:[${this.activeTraits.join(',')}]}`;
     }
 }
 exports.Spike = Spike;

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

@@ -5,7 +5,7 @@ interface SubstitutionOpts extends RallyEventOpts {
 }
 export declare class Substitution extends RallyEvent {
     readonly playerOut: string;
-    constructor({ order, playerOut, player, eventType }: SubstitutionOpts);
+    constructor({ playerOut, player, eventType }: SubstitutionOpts);
     toString(): string;
 }
 export {};

package/dist/cjs/src/service/event/substitution.js

@@ -3,12 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Substitution = void 0;
 const rally_event_1 = require("./rally-event");
 class Substitution extends rally_event_1.RallyEvent {
-    constructor({ order, playerOut, player, eventType }) {
-        super({ eventType, player, order });
+    constructor({ playerOut, player, eventType }) {
+        super({ eventType, player });
         this.playerOut = playerOut.id;
     }
     toString() {
-        return `{order:${this.order},score:${this.order},player:${this.player},playerOut:${this.playerOut},eventType:${this.eventType}}`;
+        return `{player:${this.player},playerOut:${this.playerOut},eventType:${this.eventType}}`;
     }
 }
 exports.Substitution = Substitution;

package/dist/esm/src/data/transformers/rally.js

@@ -32,42 +32,35 @@ function transformToAttributes(rally, setId) {
 }
 function transformToObject(model) {
     const decompressed = JSON.parse(decompressFromBase64(model.events));
-    const liberoReplacements = [];
-    const substitutions = [];
-    const serves = [];
-    const receptions = [];
-    const sets = [];
-    const spikes = [];
-    const blocks = [];
+    const events = [];
     decompressed.forEach(event => {
         switch (event.event_type) {
             case 0:
-                liberoReplacements.push(event);
+                events.push(event);
                 break;
             case 1:
-                substitutions.push(event);
+                events.push(event);
                 break;
             case 2:
-                serves.push(event);
+                events.push(event);
                 break;
             case 3:
-                receptions.push(event);
+                events.push(event);
                 break;
             case 4:
-                sets.push(event);
+                events.push(event);
                 break;
             case 5:
-                spikes.push(event);
+                events.push(event);
                 break;
             case 6:
-                blocks.push(event);
+                events.push(event);
                 break;
             default:
                 throw new Error('UNKNOWN_EVENT');
         }
+        events.push(event);
     });
-    const events = [...liberoReplacements, ...substitutions, ...serves, ...receptions, ...sets, ...spikes, ...blocks]
-        .sort((e1, e2) => e1.order - e2.order);
     return new Rally({
         id: model.rally_id,
         order: model.order,
@@ -77,42 +70,34 @@ function transformToObject(model) {
 }
 function transformToAPIObject(model) {
     const decompressed = JSON.parse(decompressFromBase64(model.events));
-    const liberoReplacements = [];
-    const substitutions = [];
-    const serves = [];
-    const receptions = [];
-    const sets = [];
-    const spikes = [];
-    const blocks = [];
+    const events = [];
     decompressed.forEach(event => {
         switch (event.event_type) {
             case 0:
-                liberoReplacements.push(transformToAPILiberoReplacement(event));
+                events.push(transformToAPILiberoReplacement(event));
                 break;
             case 1:
-                substitutions.push(transformToAPISubstitution(event));
+                events.push(transformToAPISubstitution(event));
                 break;
             case 2:
-                serves.push(transformToAPIServe(event));
+                events.push(transformToAPIServe(event));
                 break;
             case 3:
-                receptions.push(transformToAPIReception(event));
+                events.push(transformToAPIReception(event));
                 break;
             case 4:
-                sets.push(transformToAPISet(event));
+                events.push(transformToAPISet(event));
                 break;
             case 5:
-                spikes.push(transformToAPISpike(event));
+                events.push(transformToAPISpike(event));
                 break;
             case 6:
-                blocks.push(transformToAPIBlock(event));
+                events.push(transformToAPIBlock(event));
                 break;
             default:
                 throw new Error('UNKNOWN_EVENT');
         }
     });
-    const events = [...liberoReplacements, ...substitutions, ...serves, ...receptions, ...sets, ...spikes, ...blocks]
-        .sort((e1, e2) => e1.order - e2.order);
     return {
         id: model.rally_id,
         order: model.order,

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

@@ -23,7 +23,7 @@ export declare class Block extends InPlayEvent {
     readonly failure: BlockFailureEnum;
     readonly type: BlockTypeEnum;
     readonly blockers: string[];
-    constructor({ order, score, player, target, failure, type, modifier, eventType, blockers, activeTraits }: BlockOpts);
+    constructor({ score, player, target, failure, type, modifier, eventType, blockers, activeTraits }: BlockOpts);
     static getScore(blockers: Player[], modifier: number, activeTraits: Trait[]): number;
     toString(): string;
 }

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

@@ -17,8 +17,8 @@ export var BlockTypeEnum;
     BlockTypeEnum[BlockTypeEnum["TRIPLE"] = 3] = "TRIPLE";
 })(BlockTypeEnum || (BlockTypeEnum = {}));
 export class Block extends InPlayEvent {
-    constructor({ order, score, player, target, failure, type, modifier, eventType, blockers, activeTraits }) {
-        super({ order, score, player, target, modifier, eventType, activeTraits });
+    constructor({ score, player, target, failure, type, modifier, eventType, blockers, activeTraits }) {
+        super({ score, player, target, modifier, eventType, activeTraits });
         this.type = type;
         this.failure = failure;
         this.blockers = blockers.map(b => b.id);
@@ -59,6 +59,6 @@ export class Block extends InPlayEvent {
         return score;
     }
     toString() {
-        return `{order:${this.order},score:${this.order},player:${this.player},target:${this.target},failure:${this.failure},type:${this.type},modifier:${this.modifier},eventType:${this.eventType},blockers:[${this.blockers.join(',')}],activeTraits:[${this.activeTraits.join(',')}]}`;
+        return `{score:${this.score},player:${this.player},target:${this.target},failure:${this.failure},type:${this.type},modifier:${this.modifier},eventType:${this.eventType},blockers:[${this.blockers.join(',')}],activeTraits:[${this.activeTraits.join(',')}]}`;
     }
 }

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

@@ -14,6 +14,6 @@ export declare abstract class InPlayEvent extends RallyEvent {
     readonly modifier: number;
     readonly score: number;
     readonly activeTraits: string[];
-    protected constructor({ eventType, player, target, modifier, score, order, activeTraits }: InPlayEventOpts);
+    protected constructor({ eventType, player, target, modifier, score, activeTraits }: InPlayEventOpts);
     protected static calculateScore(stats: PerformanceStats, eventType: string, type: string): number;
 }

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

@@ -2,8 +2,8 @@ import { RallyEvent } from './rally-event';
 import formula from '../../../data/event.formula.json';
 import { getKeys } from '../utils';
 export class InPlayEvent extends RallyEvent {
-    constructor({ eventType, player, target, modifier, score, order, activeTraits }) {
-        super({ order, player, eventType });
+    constructor({ eventType, player, target, modifier, score, activeTraits }) {
+        super({ player, eventType });
         this.target = target;
         this.score = score;
         this.modifier = modifier;

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

@@ -12,7 +12,7 @@ export declare enum LiberoReplacementTypeEnum {
 export declare class LiberoReplacement extends RallyEvent {
     readonly type: LiberoReplacementTypeEnum;
     readonly libero: string;
-    constructor({ order, player, type, libero, eventType }: LiberoReplacementOpts);
+    constructor({ player, type, libero, eventType }: LiberoReplacementOpts);
     toString(): string;
 }
 export {};

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

@@ -5,12 +5,12 @@ export var LiberoReplacementTypeEnum;
     LiberoReplacementTypeEnum[LiberoReplacementTypeEnum["LIBERO_OUT"] = 1] = "LIBERO_OUT";
 })(LiberoReplacementTypeEnum || (LiberoReplacementTypeEnum = {}));
 export class LiberoReplacement extends RallyEvent {
-    constructor({ order, player, type, libero, eventType }) {
-        super({ order, player, eventType });
+    constructor({ player, type, libero, eventType }) {
+        super({ player, eventType });
         this.type = type;
         this.libero = libero.id;
     }
     toString() {
-        return `{order:${this.order},player:${this.player},type:${this.type},eventType:${this.eventType},libero:${this.libero}}`;
+        return `{player:${this.player},type:${this.type},eventType:${this.eventType},libero:${this.libero}}`;
     }
 }

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

@@ -11,11 +11,9 @@ export declare enum EventTypeEnum {
 export interface RallyEventOpts {
     readonly player: Player;
     readonly eventType: EventTypeEnum;
-    readonly order: number;
 }
 export declare abstract class RallyEvent {
-    readonly order: number;
     readonly player: string;
     readonly eventType: EventTypeEnum;
-    protected constructor({ eventType, player, order }: RallyEventOpts);
+    protected constructor({ eventType, player }: RallyEventOpts);
 }

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

@@ -9,9 +9,8 @@ export var EventTypeEnum;
     EventTypeEnum[EventTypeEnum["BLOCK"] = 6] = "BLOCK";
 })(EventTypeEnum || (EventTypeEnum = {}));
 export class RallyEvent {
-    constructor({ eventType, player, order }) {
+    constructor({ eventType, player }) {
         this.player = player.id;
-        this.order = order;
         this.eventType = eventType;
     }
 }

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

@@ -20,7 +20,7 @@ interface ReceptionOpts extends InPlayEventOpts {
 export declare class Reception extends InPlayEvent {
     readonly failure: ReceptionFailureEnum;
     readonly type: ReceptionTypeEnum;
-    constructor({ order, score, player, target, failure, type, eventType, modifier, activeTraits }: ReceptionOpts);
+    constructor({ score, player, target, failure, type, eventType, modifier, activeTraits }: ReceptionOpts);
     static getScore(stats: PerformanceStats, type: ReceptionTypeEnum, modifier: number, activeTraits: Trait[]): number;
     toString(): string;
 }

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

@@ -16,8 +16,8 @@ export var ReceptionFailureEnum;
     ReceptionFailureEnum[ReceptionFailureEnum["BAD_PASS"] = 4] = "BAD_PASS";
 })(ReceptionFailureEnum || (ReceptionFailureEnum = {}));
 export class Reception extends InPlayEvent {
-    constructor({ order, score, player, target, failure, type, eventType, modifier, activeTraits }) {
-        super({ order, score, player, target, eventType, modifier, activeTraits });
+    constructor({ score, player, target, failure, type, eventType, modifier, activeTraits }) {
+        super({ score, player, target, eventType, modifier, activeTraits });
         this.type = type;
         this.failure = failure;
     }
@@ -34,6 +34,6 @@ export class Reception extends InPlayEvent {
         return score;
     }
     toString() {
-        return `{order:${this.order},score:${this.order},player:${this.player},target:${this.target},failure:${this.failure},type:${this.type},modifier:${this.modifier},eventType:${this.eventType},activeTraits:[${this.activeTraits.join(',')}]}`;
+        return `{score:${this.score},player:${this.player},target:${this.target},failure:${this.failure},type:${this.type},modifier:${this.modifier},eventType:${this.eventType},activeTraits:[${this.activeTraits.join(',')}]}`;
     }
 }

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

@@ -21,7 +21,7 @@ interface ServeOpts extends InPlayEventOpts {
 export declare class Serve extends InPlayEvent {
     readonly failure: ServeFailureEnum;
     readonly type: ServeTypeEnum;
-    constructor({ order, score, player, target, failure, type, eventType, modifier, activeTraits }: ServeOpts);
+    constructor({ score, player, target, failure, type, eventType, modifier, activeTraits }: ServeOpts);
     static getScore(stats: PerformanceStats, type: ServeTypeEnum, modifier: number, activeTraits: Trait[]): number;
     toString(): string;
 }

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

@@ -16,8 +16,8 @@ export var ServeFailureEnum;
     ServeFailureEnum[ServeFailureEnum["OUT_OF_BOUNDS"] = 4] = "OUT_OF_BOUNDS";
 })(ServeFailureEnum || (ServeFailureEnum = {}));
 export class Serve extends InPlayEvent {
-    constructor({ order, score, player, target, failure, type, eventType, modifier, activeTraits }) {
-        super({ order, score, player, target, eventType, modifier, activeTraits });
+    constructor({ score, player, target, failure, type, eventType, modifier, activeTraits }) {
+        super({ score, player, target, eventType, modifier, activeTraits });
         this.type = type;
         this.failure = failure;
     }
@@ -29,6 +29,6 @@ export class Serve extends InPlayEvent {
         return score;
     }
     toString() {
-        return `{order:${this.order},score:${this.order},player:${this.player},target:${this.target},failure:${this.failure},type:${this.type},modifier:${this.modifier},eventType:${this.eventType},activeTraits:[${this.activeTraits.join(',')}]}`;
+        return `{score:${this.score},player:${this.player},target:${this.target},failure:${this.failure},type:${this.type},modifier:${this.modifier},eventType:${this.eventType},activeTraits:[${this.activeTraits.join(',')}]}`;
     }
 }

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

@@ -20,7 +20,7 @@ interface SetOpts extends InPlayEventOpts {
 export declare class Set extends InPlayEvent {
     readonly failure: SetFailureEnum;
     readonly type: SetTypeEnum;
-    constructor({ order, score, player, target, failure, type, eventType, modifier, activeTraits }: SetOpts);
+    constructor({ score, player, target, failure, type, eventType, modifier, activeTraits }: SetOpts);
     static getScore(stats: PerformanceStats, type: SetTypeEnum, modifier: number, activeTraits: Trait[]): number;
     toString(): string;
 }

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

@@ -16,8 +16,8 @@ export var SetFailureEnum;
     SetFailureEnum[SetFailureEnum["OUT_OF_BOUNDS"] = 4] = "OUT_OF_BOUNDS";
 })(SetFailureEnum || (SetFailureEnum = {}));
 export class Set extends InPlayEvent {
-    constructor({ order, score, player, target, failure, type, eventType, modifier, activeTraits }) {
-        super({ order, score, player, target, eventType, modifier, activeTraits });
+    constructor({ score, player, target, failure, type, eventType, modifier, activeTraits }) {
+        super({ score, player, target, eventType, modifier, activeTraits });
         this.type = type;
         this.failure = failure;
     }
@@ -39,6 +39,6 @@ export class Set extends InPlayEvent {
         return score;
     }
     toString() {
-        return `{order:${this.order},score:${this.order},player:${this.player},target:${this.target},failure:${this.failure},type:${this.type},modifier:${this.modifier},eventType:${this.eventType},activeTraits:[${this.activeTraits.join(',')}]}`;
+        return `{score:${this.score},player:${this.player},target:${this.target},failure:${this.failure},type:${this.type},modifier:${this.modifier},eventType:${this.eventType},activeTraits:[${this.activeTraits.join(',')}]}`;
     }
 }

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

@@ -22,7 +22,7 @@ interface SpikeOpts extends InPlayEventOpts {
 export declare class Spike extends InPlayEvent {
     readonly failure: SpikeFailureEnum;
     readonly type: SpikeTypeEnum;
-    constructor({ order, score, player, target, failure, type, eventType, modifier, activeTraits }: SpikeOpts);
+    constructor({ score, player, target, failure, type, eventType, modifier, activeTraits }: SpikeOpts);
     static getScore(player: Player, type: SpikeTypeEnum, modifier: number, isBackRow: boolean, activeTraits: Trait[]): number;
     toString(): string;
 }

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

@@ -18,8 +18,8 @@ export var SpikeFailureEnum;
     SpikeFailureEnum[SpikeFailureEnum["NET"] = 4] = "NET";
 })(SpikeFailureEnum || (SpikeFailureEnum = {}));
 export class Spike extends InPlayEvent {
-    constructor({ order, score, player, target, failure, type, eventType, modifier, activeTraits }) {
-        super({ order, score, player, target, eventType, modifier, activeTraits });
+    constructor({ score, player, target, failure, type, eventType, modifier, activeTraits }) {
+        super({ score, player, target, eventType, modifier, activeTraits });
         this.type = type;
         this.failure = failure;
     }
@@ -44,6 +44,6 @@ export class Spike extends InPlayEvent {
         return score;
     }
     toString() {
-        return `{order:${this.order},score:${this.order},player:${this.player},target:${this.target},failure:${this.failure},type:${this.type},modifier:${this.modifier},eventType:${this.eventType},activeTraits:[${this.activeTraits.join(',')}]}`;
+        return `{score:${this.score},player:${this.player},target:${this.target},failure:${this.failure},type:${this.type},modifier:${this.modifier},eventType:${this.eventType},activeTraits:[${this.activeTraits.join(',')}]}`;
     }
 }

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

@@ -5,7 +5,7 @@ interface SubstitutionOpts extends RallyEventOpts {
 }
 export declare class Substitution extends RallyEvent {
     readonly playerOut: string;
-    constructor({ order, playerOut, player, eventType }: SubstitutionOpts);
+    constructor({ playerOut, player, eventType }: SubstitutionOpts);
     toString(): string;
 }
 export {};

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

@@ -1,10 +1,10 @@
 import { RallyEvent } from './rally-event';
 export class Substitution extends RallyEvent {
-    constructor({ order, playerOut, player, eventType }) {
-        super({ eventType, player, order });
+    constructor({ playerOut, player, eventType }) {
+        super({ eventType, player });
         this.playerOut = playerOut.id;
     }
     toString() {
-        return `{order:${this.order},score:${this.order},player:${this.player},playerOut:${this.playerOut},eventType:${this.eventType}}`;
+        return `{player:${this.player},playerOut:${this.playerOut},eventType:${this.eventType}}`;
     }
 }

package/package.json

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