volleyballsimtypes 0.0.98 → 0.0.100

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

@@ -1,5 +1,5 @@
 import { Set, SetFailureEnum, SetTypeEnum } from '../../service';
-import { transformFromCourtTarget, transformFromEventType, transformToCourtTarget, transformToEventType, transformToPlayer, transformToTrait } from '.';
+import { transformFromCourtTarget, transformFromEventType, transformToCourtTarget, transformToEventType, transformToPlayer } from '.';
 function transformToSetFailure(failure) {
     switch (failure) {
         case SetFailureEnum.NO_FAILURE:
@@ -37,23 +37,15 @@ function transformFromSetType(type) {
     return SetTypeEnum[type];
 }
 function transformToAttributes(event, rallyId) {
-    const eventTraits = event.activeTraits.map(trait => ({
-        event_id: event.id,
-        set_id: event.id,
-        trait_id: trait.id
-    }));
     return {
         event_id: event.id,
         player_id: event.player.id,
         rally_id: rallyId,
         order: event.order,
-        modifier: event.modifier,
-        score: event.score,
         target: transformFromCourtTarget(event.target),
         failure: transformToSetFailure(event.failure),
         type: transformToSetType(event.type),
-        event_type: transformFromEventType(event.eventType),
-        EventTraits: eventTraits
+        event_type: transformFromEventType(event.eventType)
     };
 }
 function transformToObject(set) {
@@ -64,10 +56,10 @@ function transformToObject(set) {
         type: transformFromSetType(set.type),
         player: transformToPlayer(set.player),
         target: transformToCourtTarget(set.target),
-        modifier: set.modifier,
         order: set.order,
-        score: set.score,
-        activeTraits: set.Traits.map(transformToTrait)
+        modifier: 1,
+        score: 1,
+        activeTraits: []
     });
 }
 function transformToAPIObject(event) {
@@ -78,9 +70,7 @@ function transformToAPIObject(event) {
         type: transformFromSetType(event.type),
         playerId: event.player_id,
         target: transformToCourtTarget(event.target),
-        modifier: event.modifier,
-        order: event.order,
-        score: event.score
+        order: event.order
     };
 }
 export { transformToObject as transformToSet, transformToAPIObject as transformToAPISet, transformToAttributes as transformFromSet };

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

@@ -1,5 +1,5 @@
 import { Spike, SpikeFailureEnum, SpikeTypeEnum } from '../../service';
-import { transformFromCourtTarget, transformFromEventType, transformToCourtTarget, transformToEventType, transformToPlayer, transformToTrait } from '.';
+import { transformFromCourtTarget, transformFromEventType, transformToCourtTarget, transformToEventType, transformToPlayer } from '.';
 function transformToSpikeFailure(failure) {
     switch (failure) {
         case SpikeFailureEnum.NO_FAILURE:
@@ -41,23 +41,15 @@ function transformFromSpikeType(type) {
     return SpikeTypeEnum[type];
 }
 function transformToAttributes(event, rallyId) {
-    const eventTraits = event.activeTraits.map(trait => ({
-        event_id: event.id,
-        spike_id: event.id,
-        trait_id: trait.id
-    }));
     return {
         event_id: event.id,
         player_id: event.player.id,
         rally_id: rallyId,
         order: event.order,
-        modifier: event.modifier,
-        score: event.score,
         target: transformFromCourtTarget(event.target),
         failure: transformToSpikeFailure(event.failure),
         type: transformToSpikeType(event.type),
-        event_type: transformFromEventType(event.eventType),
-        EventTraits: eventTraits
+        event_type: transformFromEventType(event.eventType)
     };
 }
 function transformToObject(spike) {
@@ -68,10 +60,10 @@ function transformToObject(spike) {
         type: transformFromSpikeType(spike.type),
         player: transformToPlayer(spike.player),
         target: transformToCourtTarget(spike.target),
-        modifier: spike.modifier,
         order: spike.order,
-        score: spike.score,
-        activeTraits: spike.Traits.map(transformToTrait)
+        modifier: 1,
+        score: 1,
+        activeTraits: []
     });
 }
 function transformToAPIObject(event) {
@@ -82,9 +74,7 @@ function transformToAPIObject(event) {
         type: transformFromSpikeType(event.type),
         playerId: event.player_id,
         target: transformToCourtTarget(event.target),
-        modifier: event.modifier,
         order: event.order,
-        score: event.score
     };
 }
 export { transformToObject as transformToSpike, transformToAPIObject as transformToAPISpike, transformToAttributes as transformFromSpike };

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

@@ -3,12 +3,7 @@ import { APITrait } from '../../api';
 function transformToAttributes(trait) {
     return {
         trait_id: trait.id,
-        name: trait.name,
-        modifier: trait.modifier,
-        chance: trait.chance,
-        weight: trait.weight,
-        threshold: trait.statThreshold,
-        general_stat: trait.stat
+        name: trait.name
     };
 }
 function transformToAPIObject(model) {

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

@@ -38,11 +38,9 @@ export const finishedSet = (() => {
         homeLibero: libero,
         awayLibero: libero
     });
-    set.nextState();
     for (let i = 0; i < 25; i++) {
         set.increaseScore(MatchTeam.HOME);
     }
-    set.nextState();
     return set;
 })();
 export const inProgressSet = (() => {
@@ -57,7 +55,6 @@ export const inProgressSet = (() => {
         homeLibero: libero,
         awayLibero: libero
     });
-    set.nextState();
     for (let i = 0; i < 20; i++) {
         set.increaseScore(MatchTeam.AWAY);
     }

package/dist/esm/src/service/match/match-set.d.ts

@@ -1,14 +1,6 @@
 import { Rally } from './rally';
 import { MatchTeam } from './match-team';
 import { Player } from '../player';
-export declare enum MatchSetState {
-    NEW = 0,
-    IN_PLAY = 1,
-    FINISHED = 2
-}
-export declare namespace MatchSetState {
-    function nextState(state: number): MatchSetState;
-}
 interface MatchSetOpts {
     readonly id: string;
     readonly order: number;
@@ -50,9 +42,7 @@ export declare class MatchSet {
     private readonly scoreThreshold;
     private homeScore;
     private awayScore;
-    private _state;
     constructor({ id, order, isTieBreak, homeLibero, awayLibero, stats, rallies, homeScore, awayScore }: MatchSetOpts);
-    get state(): MatchSetState;
     getHomeScore(): number;
     getAwayScore(): number;
     increaseScore(team: MatchTeam): void;
@@ -62,7 +52,6 @@ export declare class MatchSet {
      * @returns boolean
      */
     isOver(): boolean;
-    nextState(): void;
     /**
      * Get the team that won the Set. Return undefined if set is not over.
      * @returns CourtTeam

package/dist/esm/src/service/match/match-set.js

@@ -1,22 +1,5 @@
 import { validateUUID } from '../utils';
 import { MatchTeam } from './match-team';
-export var MatchSetState;
-(function (MatchSetState) {
-    MatchSetState[MatchSetState["NEW"] = 0] = "NEW";
-    MatchSetState[MatchSetState["IN_PLAY"] = 1] = "IN_PLAY";
-    MatchSetState[MatchSetState["FINISHED"] = 2] = "FINISHED";
-})(MatchSetState || (MatchSetState = {}));
-// eslint-disable-next-line @typescript-eslint/no-namespace
-(function (MatchSetState) {
-    function nextState(state) {
-        if (state < 0 || state > 2)
-            throw new Error('STATE_INDEX_OUT_OF_BOUNDS');
-        if (state === 2)
-            throw new Error(`CANT_GET_STATE_AFTER: ${MatchSetState[state]}`);
-        return state + 1;
-    }
-    MatchSetState.nextState = nextState;
-})(MatchSetState || (MatchSetState = {}));
 var ScoreThreshold;
 (function (ScoreThreshold) {
     ScoreThreshold[ScoreThreshold["SET"] = 25] = "SET";
@@ -35,10 +18,6 @@ export class MatchSet {
         this.rallies = rallies;
         this.isTieBreak = isTieBreak;
         this.scoreThreshold = isTieBreak ? ScoreThreshold.TIE_BREAK : ScoreThreshold.SET;
-        this._state = MatchSetState.NEW;
-    }
-    get state() {
-        return this._state;
     }
     getHomeScore() {
         return this.homeScore;
@@ -47,8 +26,6 @@ export class MatchSet {
         return this.awayScore;
     }
     increaseScore(team) {
-        if (this._state !== MatchSetState.IN_PLAY || this.isOver())
-            throw new Error('CANNOT_INCREASE_SCORE_OF_SET');
         if (team === MatchTeam.HOME)
             this.homeScore++;
         else if (team === MatchTeam.AWAY)
@@ -67,12 +44,6 @@ export class MatchSet {
         return Math.abs(this.homeScore - this.awayScore) > 1 &&
             (this.homeScore >= this.scoreThreshold || this.awayScore >= this.scoreThreshold);
     }
-    nextState() {
-        if (this._state === 1 && !this.isOver()) {
-            throw new Error('CANNOT_ADVANCE_SET_STATE');
-        }
-        this._state = MatchSetState.nextState(this._state);
-    }
     /**
      * Get the team that won the Set. Return undefined if set is not over.
      * @returns CourtTeam

package/dist/esm/src/service/match/match-set.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, test } from '@jest/globals';
-import { MatchSet, MatchSetState } from './match-set';
+import { MatchSet } from './match-set';
 import { MatchTeam } from './match-team';
 import { newRally } from './__stubs__';
 import { libero } from '../player/__stubs__';
@@ -33,25 +33,21 @@ describe('MatchSet Test Module', () => {
     test('Should instantiate object properly', () => {
         expect(set.id).toBe('4a8d1149-0157-461c-afb4-8a2d9776da5a');
         expect(set.rallies.length).toBe(0);
-        expect(set.state).toBe(0);
         expect(set.getHomeScore()).toBe(0);
         expect(set.getAwayScore()).toBe(0);
     });
     // increaseScore Tests
     test('Should increase score of home team', () => {
-        set.nextState();
         expect(set.getHomeScore).toBe(0);
         set.increaseScore(MatchTeam.HOME);
         expect(set.getHomeScore).toBe(1);
     });
     test('Should increase score of away team', () => {
-        set.nextState();
         expect(set.getAwayScore).toBe(0);
         set.increaseScore(MatchTeam.AWAY);
         expect(set.getAwayScore).toBe(1);
     });
     test('Should throw Error when trying to increase score of finished set', () => {
-        set.nextState();
         for (let i = 0; i < 25; i++)
             set.increaseScore(MatchTeam.HOME);
         function fin1() { set.increaseScore(MatchTeam.HOME); }
@@ -60,7 +56,6 @@ describe('MatchSet Test Module', () => {
         expect(fin2).toThrow(/^CANNOT_INCREASE_SCORE_OF_SET$/);
     });
     test('Should throw Error when providing invalid team', () => {
-        set.nextState();
         // @ts-expect-error
         function fin() { set.increaseScore(MatchTeam.OTHER); }
         expect(fin).toThrow(/^UNKNOWN_TEAM$/);
@@ -73,14 +68,12 @@ describe('MatchSet Test Module', () => {
     });
     // isOver Tests
     test('Should return true for team reaching point threshold', () => {
-        set.nextState();
         expect(set.isOver()).toBe(false);
         for (let i = 0; i < 25; i++)
             set.increaseScore(MatchTeam.HOME);
         expect(set.isOver()).toBe(true);
     });
     test('Should return true for both teams reaching point threshold and point difference greater than 1', () => {
-        set.nextState();
         for (let i = 0; i < 25; i++) {
             set.increaseScore(MatchTeam.HOME);
             set.increaseScore(MatchTeam.AWAY);
@@ -91,60 +84,17 @@ describe('MatchSet Test Module', () => {
         set.increaseScore(MatchTeam.HOME);
         expect(set.isOver()).toBe(true);
     });
-    // nextState Tests
-    test('Should advance to in play', () => {
-        expect(set.state).toBe(0);
-        set.nextState();
-        expect(set.state).toBe(1);
-    });
-    test('Should throw Error if in play and set not over', () => {
-        set.nextState();
-        function fin() { set.nextState(); }
-        expect(fin).toThrow(/^CANNOT_ADVANCE_SET_STATE$/);
-    });
-    test('Should advance to FINISHED if set is over', () => {
-        set.nextState();
-        for (let i = 0; i < 25; i++)
-            set.increaseScore(MatchTeam.HOME);
-        set.nextState();
-        expect(set.state).toBe(2);
-    });
-    test('Should throw Error when trying to transition from FINISHED state', () => {
-        set.nextState();
-        for (let i = 0; i < 25; i++)
-            set.increaseScore(MatchTeam.HOME);
-        set.nextState();
-        function fin() { set.nextState(); }
-        expect(fin).toThrow(/^CANT_GET_STATE_AFTER: FINISHED$/);
-    });
     // getWinner Tests
     test('Should throw Error when getting winner of unfinished set', () => {
         function fin() { set.getWinner(); }
         expect(fin).toThrow(/^UNFINISHED_SET$/);
     });
     test('Should get correct set winner', () => {
-        set.nextState();
         for (let i = 0; i < 25; i++)
             set.increaseScore(MatchTeam.HOME);
         expect(set.getWinner()).toBe(MatchTeam.HOME);
-        tieBreakSet.nextState();
         for (let i = 0; i < 15; i++)
             tieBreakSet.increaseScore(MatchTeam.AWAY);
         expect(tieBreakSet.getWinner()).toBe(MatchTeam.AWAY);
     });
-    // MatchSetState Tests
-    test('Should get next state', () => {
-        expect(MatchSetState.nextState(0)).toBe(1);
-        expect(MatchSetState.nextState(1)).toBe(2);
-    });
-    test('Should throw Error for state outside range', () => {
-        function fn1() { MatchSetState.nextState(-1); }
-        function fn2() { MatchSetState.nextState(3); }
-        expect(fn1).toThrow(/^STATE_INDEX_OUT_OF_BOUNDS$/);
-        expect(fn2).toThrow(/^STATE_INDEX_OUT_OF_BOUNDS$/);
-    });
-    test('Should throw Error for last state', () => {
-        function fn() { MatchSetState.nextState(2); }
-        expect(fn).toThrow(/^CANT_GET_STATE_AFTER: FINISHED$/);
-    });
 });

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

@@ -1,7 +1,6 @@
 import { Team } from '../team';
 import { CourtPosition } from './court-position';
-import { RallyEvent } from '../event/rally-event';
-import { Score } from '../event/score';
+import { RallyEvent, Score } from '../event';
 interface RallyOpts {
     readonly id: string;
     readonly order: number;
@@ -14,15 +13,6 @@ export interface PlayerPosition {
     position: CourtPosition;
     playerId: string;
 }
-export declare enum RallyState {
-    NEW = 0,
-    MANAGEMENT = 1,
-    IN_PLAY = 2,
-    FINISHED = 3
-}
-export declare namespace RallyState {
-    function nextState(state: number): RallyState;
-}
 export declare class Rally {
     readonly id: string;
     readonly servingTeam: Team;
@@ -30,12 +20,8 @@ export declare class Rally {
     readonly homePlayerPosition: PlayerPosition[];
     readonly awayPlayerPosition: PlayerPosition[];
     readonly order: number;
-    private _state;
     constructor({ id, order, servingTeam, homePlayerPosition, awayPlayerPosition, events }: RallyOpts);
-    get state(): RallyState;
     get score(): Score | undefined;
-    isOver(): boolean;
     addEvent(event: RallyEvent): void;
-    nextState(): void;
 }
 export {};

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

@@ -1,23 +1,5 @@
 import { validateUUID } from '../utils';
-import { EventTypeEnum } from '../event/rally-event';
-export var RallyState;
-(function (RallyState) {
-    RallyState[RallyState["NEW"] = 0] = "NEW";
-    RallyState[RallyState["MANAGEMENT"] = 1] = "MANAGEMENT";
-    RallyState[RallyState["IN_PLAY"] = 2] = "IN_PLAY";
-    RallyState[RallyState["FINISHED"] = 3] = "FINISHED";
-})(RallyState || (RallyState = {}));
-// eslint-disable-next-line @typescript-eslint/no-namespace
-(function (RallyState) {
-    function nextState(state) {
-        if (state < 0 || state > 3)
-            throw new Error('STATE_INDEX_OUT_OF_BOUNDS');
-        if (state === 3)
-            throw new Error(`CANT_GET_STATE_AFTER: ${RallyState[state]}`);
-        return state + 1;
-    }
-    RallyState.nextState = nextState;
-})(RallyState || (RallyState = {}));
+import { EventTypeEnum } from '../event';
 export class Rally {
     constructor({ id, order, servingTeam, homePlayerPosition, awayPlayerPosition, events }) {
         validateUUID(id);
@@ -27,21 +9,11 @@ export class Rally {
         this.homePlayerPosition = homePlayerPosition;
         this.awayPlayerPosition = awayPlayerPosition;
         this.events = events;
-        this._state = RallyState.NEW;
-    }
-    get state() {
-        return this._state;
     }
     get score() {
         return this.events.find(e => e.eventType === EventTypeEnum.SCORE);
     }
-    isOver() {
-        return this._state === RallyState.FINISHED;
-    }
     addEvent(event) {
         this.events.push(event);
     }
-    nextState() {
-        this._state = RallyState.nextState(this._state);
-    }
 }

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

@@ -1,7 +1,7 @@
 import { describe, expect, test } from '@jest/globals';
-import { Rally, RallyState } from './rally';
+import { Rally } from './rally';
 import { score, serve } from '../event/__stubs__';
-import { EventTypeEnum } from '../event/rally-event';
+import { EventTypeEnum } from '../event';
 import { team } from '../team/__stubs__';
 describe('Rally Test Module', () => {
     let rally;
@@ -19,26 +19,6 @@ describe('Rally Test Module', () => {
         expect(rally.id).toBe('0ac3ba3a-d710-42dc-a1e7-7066b8df5fd9');
         expect(rally.servingTeam.id).toBe('426b5b9b-5be7-4963-92eb-71b7a3b29ffd');
         expect(rally.events.length).toBe(0);
-        expect(rally.state).toBe(0);
-    });
-    // nextState Tests
-    test('Should cycle through states correctly', () => {
-        expect(rally.state).toBe(0);
-        rally.nextState();
-        expect(rally.state).toBe(1);
-        rally.nextState();
-        expect(rally.state).toBe(2);
-        rally.nextState();
-        expect(rally.state).toBe(3);
-    });
-    test('Should throw Error when trying to get next state after FINISHED', () => {
-        function state() {
-            rally.nextState();
-            rally.nextState();
-            rally.nextState();
-            rally.nextState();
-        }
-        expect(state).toThrow(/^CANT_GET_STATE_AFTER: FINISHED$/);
     });
     // addEvent Tests
     test('Should add event to event array', () => {
@@ -46,18 +26,6 @@ describe('Rally Test Module', () => {
         rally.addEvent(serve);
         expect(rally.events.at(-1)?.eventType).toBe(EventTypeEnum.SERVE);
     });
-    // isOver Tests
-    test('Should return false if rally state is not FINISHED', () => {
-        expect(rally.state).toBe(0);
-        expect(rally.isOver()).toBe(false);
-    });
-    test('Should return true if rally state is FINISHED', () => {
-        rally.nextState();
-        rally.nextState();
-        rally.nextState();
-        expect(rally.state).toBe(3);
-        expect(rally.isOver()).toBe(true);
-    });
     // getScore Tests
     test('Should return undefined if events array does not contain a Score', () => {
         rally.addEvent(serve);
@@ -68,19 +36,4 @@ describe('Rally Test Module', () => {
         expect(rally.score).not.toBeUndefined();
         expect(rally.score?.eventType).toBe(EventTypeEnum.SCORE);
     });
-    // RallyState Tests
-    test('Should get next state', () => {
-        expect(RallyState.nextState(0)).toBe(1);
-        expect(RallyState.nextState(1)).toBe(2);
-    });
-    test('Should throw Error for state outside range', () => {
-        function fn1() { RallyState.nextState(-1); }
-        function fn2() { RallyState.nextState(4); }
-        expect(fn1).toThrow(/^STATE_INDEX_OUT_OF_BOUNDS$/);
-        expect(fn2).toThrow(/^STATE_INDEX_OUT_OF_BOUNDS$/);
-    });
-    test('Should throw Error for last state', () => {
-        function fn() { RallyState.nextState(3); }
-        expect(fn).toThrow(/^CANT_GET_STATE_AFTER: FINISHED$/);
-    });
 });

package/package.json

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

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

@@ -1,50 +0,0 @@
-import * as Sequelize from 'sequelize';
-import { Model, Optional } from 'sequelize';
-import type { BlockId, BlockModel, ReceptionId, ReceptionModel, ServeId, ServeModel, SetId, SetModel, SpikeId, SpikeModel, TraitId, TraitModel } from '.';
-export interface EventTraitAttributes {
-    block_id?: string;
-    reception_id?: string;
-    serve_id?: string;
-    set_id?: string;
-    spike_id?: string;
-    event_id: string;
-    trait_id: string;
-}
-export type EventTraitPk = 'event_id' | 'trait_id';
-export type EventTraitId = EventTraitModel[EventTraitPk];
-export type EventTraitOptionalAttributes = 'block_id' | 'reception_id' | 'serve_id' | 'set_id' | 'spike_id';
-export type EventTraitCreationAttributes = Optional<EventTraitAttributes, EventTraitOptionalAttributes>;
-export declare class EventTraitModel extends Model<EventTraitAttributes, EventTraitCreationAttributes> implements EventTraitAttributes {
-    block_id?: string;
-    reception_id?: string;
-    serve_id?: string;
-    set_id?: string;
-    spike_id?: string;
-    event_id: string;
-    trait_id: string;
-    Block: BlockModel;
-    getBlock: Sequelize.BelongsToGetAssociationMixin<BlockModel>;
-    setBlock: Sequelize.BelongsToSetAssociationMixin<BlockModel, BlockId>;
-    createBlock: Sequelize.BelongsToCreateAssociationMixin<BlockModel>;
-    Reception: ReceptionModel;
-    getReception: Sequelize.BelongsToGetAssociationMixin<ReceptionModel>;
-    setReception: Sequelize.BelongsToSetAssociationMixin<ReceptionModel, ReceptionId>;
-    createReception: Sequelize.BelongsToCreateAssociationMixin<ReceptionModel>;
-    Serve: ServeModel;
-    getServe: Sequelize.BelongsToGetAssociationMixin<ServeModel>;
-    setServe: Sequelize.BelongsToSetAssociationMixin<ServeModel, ServeId>;
-    createServe: Sequelize.BelongsToCreateAssociationMixin<ServeModel>;
-    Set: SetModel;
-    getSet: Sequelize.BelongsToGetAssociationMixin<SetModel>;
-    setSet: Sequelize.BelongsToSetAssociationMixin<SetModel, SetId>;
-    createSet: Sequelize.BelongsToCreateAssociationMixin<SetModel>;
-    Spike: SpikeModel;
-    getSpike: Sequelize.BelongsToGetAssociationMixin<SpikeModel>;
-    setSpike: Sequelize.BelongsToSetAssociationMixin<SpikeModel, SpikeId>;
-    createSpike: Sequelize.BelongsToCreateAssociationMixin<SpikeModel>;
-    Trait: TraitModel;
-    getTrait: Sequelize.BelongsToGetAssociationMixin<TraitModel>;
-    setTrait: Sequelize.BelongsToSetAssociationMixin<TraitModel, TraitId>;
-    createTrait: Sequelize.BelongsToCreateAssociationMixin<TraitModel>;
-    static initModel(sequelize: Sequelize.Sequelize): typeof EventTraitModel;
-}

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

@@ -1,77 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventTraitModel = void 0;
-const sequelize_1 = require("sequelize");
-class EventTraitModel extends sequelize_1.Model {
-    static initModel(sequelize) {
-        return EventTraitModel.init({
-            block_id: {
-                type: sequelize_1.DataTypes.UUID,
-                allowNull: true,
-                references: {
-                    model: 'Block',
-                    key: 'event_id'
-                }
-            },
-            reception_id: {
-                type: sequelize_1.DataTypes.UUID,
-                allowNull: true,
-                references: {
-                    model: 'Reception',
-                    key: 'event_id'
-                }
-            },
-            serve_id: {
-                type: sequelize_1.DataTypes.UUID,
-                allowNull: true,
-                references: {
-                    model: 'Serve',
-                    key: 'event_id'
-                }
-            },
-            set_id: {
-                type: sequelize_1.DataTypes.UUID,
-                allowNull: true,
-                references: {
-                    model: 'Set',
-                    key: 'event_id'
-                }
-            },
-            spike_id: {
-                type: sequelize_1.DataTypes.UUID,
-                allowNull: true,
-                references: {
-                    model: 'Spike',
-                    key: 'event_id'
-                }
-            },
-            event_id: {
-                type: sequelize_1.DataTypes.UUID,
-                allowNull: false,
-                primaryKey: true
-            },
-            trait_id: {
-                type: sequelize_1.DataTypes.UUID,
-                allowNull: false,
-                references: {
-                    model: 'Trait',
-                    key: 'trait_id'
-                }
-            }
-        }, {
-            sequelize,
-            tableName: 'EventTrait',
-            schema: 'public',
-            timestamps: false,
-            indexes: [{
-                    name: 'eventtrait_pk',
-                    unique: true,
-                    fields: [
-                        { name: 'event_id' },
-                        { name: 'trait_id' }
-                    ]
-                }]
-        });
-    }
-}
-exports.EventTraitModel = EventTraitModel;