volleyballsimtypes 0.0.121 → 0.0.123

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

@@ -13,7 +13,7 @@ export declare abstract class InPlayEvent extends RallyEvent {
     readonly target: CourtTargetEnum;
     readonly modifier: number;
     readonly score: number;
-    readonly activeTraits: Trait[];
-    protected constructor({ id, eventType, player, target, modifier, score, order, activeTraits }: InPlayEventOpts);
+    readonly activeTraits: string[];
+    protected constructor({ 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,12 +2,12 @@ import { RallyEvent } from './rally-event';
 import formula from '../../../data/event.formula.json';
 import { getKeys } from '../utils';
 export class InPlayEvent extends RallyEvent {
-    constructor({ id, eventType, player, target, modifier, score, order, activeTraits }) {
-        super({ id, order, player, eventType });
+    constructor({ eventType, player, target, modifier, score, order, activeTraits }) {
+        super({ order, player, eventType });
         this.target = target;
         this.score = score;
         this.modifier = modifier;
-        this.activeTraits = activeTraits;
+        this.activeTraits = activeTraits.map(trait => trait.id);
     }
     static calculateScore(stats, eventType, type) {
         const weight = formula[eventType][type];

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

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

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

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

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

@@ -9,15 +9,13 @@ export declare enum EventTypeEnum {
     BLOCK = 6
 }
 export interface RallyEventOpts {
-    readonly id: string;
     readonly player: Player;
     readonly eventType: EventTypeEnum;
     readonly order: number;
 }
 export declare abstract class RallyEvent {
-    readonly id: string;
     readonly order: number;
-    readonly player: Player;
+    readonly player: string;
     readonly eventType: EventTypeEnum;
-    protected constructor({ id, eventType, player, order }: RallyEventOpts);
+    protected constructor({ eventType, player, order }: 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({ id, eventType, player, order }) {
-        this.id = id;
-        this.player = player;
+    constructor({ eventType, player, order }) {
+        this.player = player.id;
         this.order = order;
         this.eventType = eventType;
     }

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

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

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({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }) {
-        super({ id, order, score, player, target, eventType, modifier, activeTraits });
+    constructor({ order, score, player, target, failure, type, eventType, modifier, activeTraits }) {
+        super({ order, score, player, target, eventType, modifier, activeTraits });
         this.type = type;
         this.failure = failure;
     }
@@ -33,4 +33,7 @@ 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(',')}]}`;
+    }
 }

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

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

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

@@ -1,5 +1,4 @@
 import { InPlayEvent } from './in-play-event';
-import { Trait } from '../player';
 export var ServeTypeEnum;
 (function (ServeTypeEnum) {
     ServeTypeEnum[ServeTypeEnum["UNDERHAND"] = 0] = "UNDERHAND";
@@ -17,21 +16,19 @@ export var ServeFailureEnum;
     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, activeTraits }) {
-        super({ id, order, score, player, target, eventType, modifier, activeTraits });
+    constructor({ order, score, player, target, failure, type, eventType, modifier, activeTraits }) {
+        super({ order, score, player, target, eventType, modifier, activeTraits });
         this.type = type;
         this.failure = failure;
     }
     static getScore(stats, type, modifier, activeTraits) {
         let score = Serve.calculateScore(stats, 'SERVE', ServeTypeEnum[type]) * modifier;
         for (const trait of activeTraits) {
-            switch (true) {
-                case trait === Trait.METEOR_SERVE: {
-                    score *= Trait.METEOR_SERVE.modifier;
-                    break;
-                }
-            }
+            score *= trait.modifier;
         }
         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(',')}]}`;
+    }
 }

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

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

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({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }) {
-        super({ id, order, score, player, target, eventType, modifier, activeTraits });
+    constructor({ order, score, player, target, failure, type, eventType, modifier, activeTraits }) {
+        super({ order, score, player, target, eventType, modifier, activeTraits });
         this.type = type;
         this.failure = failure;
     }
@@ -38,4 +38,7 @@ 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(',')}]}`;
+    }
 }

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

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

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({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }) {
-        super({ id, order, score, player, target, eventType, modifier, activeTraits });
+    constructor({ order, score, player, target, failure, type, eventType, modifier, activeTraits }) {
+        super({ order, score, player, target, eventType, modifier, activeTraits });
         this.type = type;
         this.failure = failure;
     }
@@ -43,4 +43,7 @@ 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(',')}]}`;
+    }
 }

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

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

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

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

package/dist/esm/src/service/player/role.js

@@ -20,10 +20,10 @@ export class Role {
             score: this.calculateScore(stats, role)
         })).sort((x, y) => y.score - x.score);
         const out = [scores[0].role];
-        if (scores[1].score >= 65) {
+        if (scores[1].score >= 75) {
             out.push(scores[1].role);
         }
-        if (scores[2].score >= 70) {
+        if (scores[2].score >= 85) {
             out.push(scores[2].role);
         }
         return out;

package/dist/esm/src/service/player/trait.js

@@ -19,13 +19,13 @@ export class Trait {
         const random = Math.random();
         let traitCount;
         switch (true) {
-            case random > 0.9:
+            case random > 0.95:
                 traitCount = 3;
                 break;
-            case random > 0.75:
+            case random > 0.85:
                 traitCount = 2;
                 break;
-            case random > 0.4:
+            case random > 0.6:
                 traitCount = 1;
                 break;
             default:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "volleyballsimtypes",
-  "version": "0.0.121",
+  "version": "0.0.123",
   "description": "vbsim types",
   "main": "./dist/cjs/src/index.js",
   "module": "./dist/esm/src/index.js",
@@ -33,6 +33,7 @@
   },
   "dependencies": {
     "@types/sequelize": "^4.28.15",
+    "lz-string": "^1.5.0",
     "moment": "^2.29.4",
     "pg": "^8.11.1",
     "pg-hstore": "^2.3.4",

package/dist/cjs/src/data/models/block.d.ts

@@ -1,56 +0,0 @@
-import * as Sequelize from 'sequelize';
-import { Model, Optional } from 'sequelize';
-import { CourtTarget, EventType, PlayerId, PlayerModel, RallyId, RallyModel } from '.';
-export interface BlockAttributes {
-    event_id: string;
-    rally_id: string;
-    order: number;
-    player_id: string;
-    target: CourtTarget;
-    type: BlockType;
-    failure: BlockFailure;
-    blocker_1?: string;
-    blocker_2?: string;
-    blocker_3?: string;
-    event_type: EventType;
-}
-export type BlockPk = 'event_id';
-export type BlockType = 'NO_BLOCKER' | 'SINGLE' | 'DOUBLE' | 'TRIPLE';
-export type BlockFailure = 'NO_FAILURE' | 'FAULT' | 'MISS' | 'OUT_OF_BOUNDS' | 'WIPE' | 'TOOL';
-export type BlockId = BlockModel[BlockPk];
-export type BlockOptionalAttributes = 'blocker_1' | 'blocker_2' | 'blocker_3';
-export type BlockCreationAttributes = Optional<BlockAttributes, BlockOptionalAttributes>;
-export declare class BlockModel extends Model<BlockAttributes, BlockCreationAttributes> implements BlockAttributes {
-    event_id: string;
-    rally_id: string;
-    order: number;
-    player_id: string;
-    target: CourtTarget;
-    type: BlockType;
-    failure: BlockFailure;
-    blocker_1?: string;
-    blocker_2?: string;
-    blocker_3?: string;
-    event_type: EventType;
-    player: PlayerModel;
-    getPlayer: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
-    setPlayer: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;
-    createPlayer: Sequelize.BelongsToCreateAssociationMixin<PlayerModel>;
-    Blocker_1: PlayerModel;
-    getBlocker_1: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
-    setBlocker_1: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;
-    createBlocker_1: Sequelize.BelongsToCreateAssociationMixin<PlayerModel>;
-    Blocker_2: PlayerModel;
-    getBlocker_2: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
-    setBlocker_2: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;
-    createBlocker_2: Sequelize.BelongsToCreateAssociationMixin<PlayerModel>;
-    Blocker_3: PlayerModel;
-    getBlocker_3: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
-    setBlocker_3: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;
-    createBlocker_3: Sequelize.BelongsToCreateAssociationMixin<PlayerModel>;
-    rally: RallyModel;
-    getRally: Sequelize.BelongsToGetAssociationMixin<RallyModel>;
-    setRally: Sequelize.BelongsToSetAssociationMixin<RallyModel, RallyId>;
-    createRally: Sequelize.BelongsToCreateAssociationMixin<RallyModel>;
-    static initModel(sequelize: Sequelize.Sequelize): typeof BlockModel;
-}

package/dist/cjs/src/data/models/block.js

@@ -1,86 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BlockModel = void 0;
-const sequelize_1 = require("sequelize");
-class BlockModel extends sequelize_1.Model {
-    static initModel(sequelize) {
-        return BlockModel.init({
-            event_id: {
-                type: sequelize_1.DataTypes.UUID,
-                allowNull: false,
-                primaryKey: true
-            },
-            rally_id: {
-                type: sequelize_1.DataTypes.UUID,
-                allowNull: false,
-                references: {
-                    model: 'Rally',
-                    key: 'rally_id'
-                }
-            },
-            order: {
-                type: sequelize_1.DataTypes.INTEGER,
-                allowNull: false
-            },
-            player_id: {
-                type: sequelize_1.DataTypes.UUID,
-                allowNull: false,
-                references: {
-                    model: 'Player',
-                    key: 'player_id'
-                }
-            },
-            target: {
-                type: sequelize_1.DataTypes.ENUM('NO_TARGET', 'OPPONENT_LEFT_BACK', 'OPPONENT_LEFT_FRONT', 'OPPONENT_MIDDLE_BACK', 'OPPONENT_MIDDLE_FRONT', 'OPPONENT_RIGHT_BACK', 'OPPONENT_RIGHT_FRONT', 'TEAM_LEFT_BACK', 'TEAM_LEFT_FRONT', 'TEAM_MIDDLE_BACK', 'TEAM_MIDDLE_FRONT', 'TEAM_RIGHT_BACK', 'TEAM_RIGHT_FRONT'),
-                allowNull: false
-            },
-            type: {
-                type: sequelize_1.DataTypes.ENUM('DOUBLE', 'NO_BLOCKER', 'SINGLE', 'TRIPLE'),
-                allowNull: false
-            },
-            failure: {
-                type: sequelize_1.DataTypes.ENUM('FAULT', 'MISS', 'NO_FAILURE', 'OUT_OF_BOUNDS', 'TOOL', 'WIPE'),
-                allowNull: false
-            },
-            blocker_1: {
-                type: sequelize_1.DataTypes.UUID,
-                allowNull: true,
-                references: {
-                    model: 'Player',
-                    key: 'player_id'
-                }
-            },
-            blocker_2: {
-                type: sequelize_1.DataTypes.UUID,
-                allowNull: true,
-                references: {
-                    model: 'Player',
-                    key: 'player_id'
-                }
-            },
-            blocker_3: {
-                type: sequelize_1.DataTypes.UUID,
-                allowNull: true,
-                references: {
-                    model: 'Player',
-                    key: 'player_id'
-                }
-            },
-            event_type: {
-                type: sequelize_1.DataTypes.ENUM('BLOCK', 'LIBERO_REPLACEMENT', 'RECEPTION', 'SERVE', 'SET', 'SPIKE', 'SUBSTITUTION'),
-                allowNull: false
-            }
-        }, {
-            sequelize,
-            tableName: 'Block',
-            schema: 'public',
-            timestamps: false,
-            indexes: [{
-                    name: 'Block_pk',
-                    unique: true,
-                    fields: [{ name: 'event_id' }]
-                }]
-        });
-    }
-}
-exports.BlockModel = BlockModel;

package/dist/cjs/src/data/models/event.d.ts

@@ -1,31 +0,0 @@
-import * as Sequelize from 'sequelize';
-import { Model } from 'sequelize';
-import { PlayerId, PlayerModel, RallyId, RallyModel } from '.';
-export interface EventAttributes {
-    event_id: string;
-    rally_id: string;
-    order: number;
-    player_id: string;
-    event_type: EventType;
-}
-export type EventType = 'LIBERO_REPLACEMENT' | 'SUBSTITUTION' | 'SERVE' | 'RECEPTION' | 'SET' | 'SPIKE' | 'BLOCK';
-export type CourtTarget = 'NO_TARGET' | 'OPPONENT_RIGHT_BACK' | 'OPPONENT_MIDDLE_BACK' | 'OPPONENT_LEFT_BACK' | 'OPPONENT_RIGHT_FRONT' | 'OPPONENT_MIDDLE_FRONT' | 'OPPONENT_LEFT_FRONT' | 'TEAM_LEFT_FRONT' | 'TEAM_MIDDLE_FRONT' | 'TEAM_RIGHT_FRONT' | 'TEAM_LEFT_BACK' | 'TEAM_MIDDLE_BACK' | 'TEAM_RIGHT_BACK';
-export type EventPk = 'event_id';
-export type EventId = EventModel[EventPk];
-export type EventCreationAttributes = EventAttributes;
-export declare class EventModel extends Model<EventAttributes, EventCreationAttributes> implements EventAttributes {
-    event_id: string;
-    rally_id: string;
-    order: number;
-    player_id: string;
-    event_type: EventType;
-    player: PlayerModel;
-    getPlayer: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
-    setPlayer: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;
-    createPlayer: Sequelize.BelongsToCreateAssociationMixin<PlayerModel>;
-    rally: RallyModel;
-    getRally: Sequelize.BelongsToGetAssociationMixin<RallyModel>;
-    setRally: Sequelize.BelongsToSetAssociationMixin<RallyModel, RallyId>;
-    createRally: Sequelize.BelongsToCreateAssociationMixin<RallyModel>;
-    static initModel(sequelize: Sequelize.Sequelize): typeof EventModel;
-}

package/dist/cjs/src/data/models/event.js

@@ -1,50 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventModel = void 0;
-const sequelize_1 = require("sequelize");
-class EventModel extends sequelize_1.Model {
-    static initModel(sequelize) {
-        return EventModel.init({
-            event_id: {
-                type: sequelize_1.DataTypes.UUID,
-                allowNull: false,
-                primaryKey: true
-            },
-            rally_id: {
-                type: sequelize_1.DataTypes.UUID,
-                allowNull: false,
-                references: {
-                    model: 'Rally',
-                    key: 'rally_id'
-                }
-            },
-            order: {
-                type: sequelize_1.DataTypes.INTEGER,
-                allowNull: false
-            },
-            player_id: {
-                type: sequelize_1.DataTypes.UUID,
-                allowNull: false,
-                references: {
-                    model: 'Player',
-                    key: 'player_id'
-                }
-            },
-            event_type: {
-                type: sequelize_1.DataTypes.ENUM('BLOCK', 'LIBERO_REPLACEMENT', 'RECEPTION', 'SERVE', 'SET', 'SPIKE', 'SUBSTITUTION'),
-                allowNull: false
-            }
-        }, {
-            sequelize,
-            tableName: 'Event',
-            schema: 'public',
-            timestamps: false,
-            indexes: [{
-                    name: 'Event_pk',
-                    unique: true,
-                    fields: [{ name: 'event_id' }]
-                }]
-        });
-    }
-}
-exports.EventModel = EventModel;

package/dist/cjs/src/data/models/libero-replacement.d.ts

@@ -1,38 +0,0 @@
-import * as Sequelize from 'sequelize';
-import { Model } from 'sequelize';
-import { EventType, PlayerId, PlayerModel, RallyId, RallyModel } from '.';
-export interface LiberoReplacementAttributes {
-    event_id: string;
-    rally_id: string;
-    order: number;
-    player_id: string;
-    type: LiberoReplacementType;
-    libero: string;
-    event_type: EventType;
-}
-export type LiberoReplacementPk = 'event_id';
-export type LiberoReplacementType = 'LIBERO_IN' | 'LIBERO_OUT';
-export type LiberoReplacementId = LiberoReplacementModel[LiberoReplacementPk];
-export type LiberoReplacementCreationAttributes = LiberoReplacementAttributes;
-export declare class LiberoReplacementModel extends Model<LiberoReplacementAttributes, LiberoReplacementCreationAttributes> implements LiberoReplacementAttributes {
-    event_id: string;
-    rally_id: string;
-    order: number;
-    player_id: string;
-    type: LiberoReplacementType;
-    libero: string;
-    event_type: EventType;
-    Libero: PlayerModel;
-    getLibero: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
-    setLibero: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;
-    createLibero: Sequelize.BelongsToCreateAssociationMixin<PlayerModel>;
-    player: PlayerModel;
-    getPlayer: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
-    setPlayer: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;
-    createPlayer: Sequelize.BelongsToCreateAssociationMixin<PlayerModel>;
-    rally: RallyModel;
-    getRally: Sequelize.BelongsToGetAssociationMixin<RallyModel>;
-    setRally: Sequelize.BelongsToSetAssociationMixin<RallyModel, RallyId>;
-    createRally: Sequelize.BelongsToCreateAssociationMixin<RallyModel>;
-    static initModel(sequelize: Sequelize.Sequelize): typeof LiberoReplacementModel;
-}

package/dist/cjs/src/data/models/libero-replacement.js

@@ -1,62 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LiberoReplacementModel = void 0;
-const sequelize_1 = require("sequelize");
-class LiberoReplacementModel extends sequelize_1.Model {
-    static initModel(sequelize) {
-        return LiberoReplacementModel.init({
-            event_id: {
-                type: sequelize_1.DataTypes.UUID,
-                allowNull: false,
-                primaryKey: true
-            },
-            rally_id: {
-                type: sequelize_1.DataTypes.UUID,
-                allowNull: false,
-                references: {
-                    model: 'Rally',
-                    key: 'rally_id'
-                }
-            },
-            order: {
-                type: sequelize_1.DataTypes.INTEGER,
-                allowNull: false
-            },
-            player_id: {
-                type: sequelize_1.DataTypes.UUID,
-                allowNull: false,
-                references: {
-                    model: 'Player',
-                    key: 'player_id'
-                }
-            },
-            type: {
-                type: sequelize_1.DataTypes.ENUM('LIBERO_IN', 'LIBERO_OUT'),
-                allowNull: false
-            },
-            libero: {
-                type: sequelize_1.DataTypes.UUID,
-                allowNull: false,
-                references: {
-                    model: 'Player',
-                    key: 'player_id'
-                }
-            },
-            event_type: {
-                type: sequelize_1.DataTypes.ENUM('BLOCK', 'LIBERO_REPLACEMENT', 'RECEPTION', 'SERVE', 'SET', 'SPIKE', 'SUBSTITUTION'),
-                allowNull: false
-            }
-        }, {
-            sequelize,
-            tableName: 'LiberoReplacement',
-            schema: 'public',
-            timestamps: false,
-            indexes: [{
-                    name: 'LiberoReplacement_pk',
-                    unique: true,
-                    fields: [{ name: 'event_id' }]
-                }]
-        });
-    }
-}
-exports.LiberoReplacementModel = LiberoReplacementModel;