volleyballsimtypes 0.0.85 → 0.0.87

package/dist/cjs/src/data/init-models.js

@@ -47,13 +47,7 @@ function initModels(sequelize) {
     Block.belongsTo(Player, { as: 'Blocker_3', foreignKey: 'blocker_3' });
     Block.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
     Block.belongsTo(Rally, { as: 'rally', foreignKey: 'rally_id' });
-    Block.belongsToMany(Trait, {
-        as: 'Traits',
-        through: EventTrait,
-        foreignKey: 'event_id',
-        otherKey: 'trait_id'
-    });
-    Block.hasMany(EventTrait, { as: 'EventTraits', foreignKey: 'event_id' });
+    Block.hasMany(EventTrait, { as: 'EventTraits', foreignKey: 'block_id' });
     Coach.belongsTo(Country, { as: 'country', foreignKey: 'country_id' });
     Coach.hasMany(Team, { as: 'Teams', foreignKey: 'coach_id' });
     Country.hasMany(Coach, { as: 'Coaches', foreignKey: 'country_id' });
@@ -62,13 +56,12 @@ function initModels(sequelize) {
     Country.hasMany(Team, { as: 'Teams', foreignKey: 'country_id' });
     Event.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
     Event.belongsTo(Rally, { as: 'rally', foreignKey: 'rally_id' });
-    Event.belongsToMany(Trait, {
-        as: 'Traits',
-        through: EventTrait,
-        foreignKey: 'event_id',
-        otherKey: 'trait_id'
-    });
-    EventTrait.belongsTo(Trait, { as: 'trait', foreignKey: 'trait_id' });
+    EventTrait.belongsTo(Block, { as: 'Block', foreignKey: 'block_id' });
+    EventTrait.belongsTo(Reception, { as: 'Reception', foreignKey: 'reception_id' });
+    EventTrait.belongsTo(Serve, { as: 'Serve', foreignKey: 'serve_id' });
+    EventTrait.belongsTo(Set, { as: 'Set', foreignKey: 'set_id' });
+    EventTrait.belongsTo(Spike, { as: 'Spike', foreignKey: 'spike_id' });
+    EventTrait.belongsTo(Trait, { as: 'Trait', foreignKey: 'trait_id' });
     Iteration.hasMany(Season, { as: 'Seasons', foreignKey: 'iteration' });
     Iteration.hasOne(Tournament, { as: 'Tournament', foreignKey: 'iteration' });
     League.belongsTo(Country, { as: 'country', foreignKey: 'country_id' });
@@ -170,13 +163,7 @@ function initModels(sequelize) {
     RallyPosition.belongsTo(Rally, { as: 'rally', foreignKey: 'rally_id' });
     Reception.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
     Reception.belongsTo(Rally, { as: 'rally', foreignKey: 'rally_id' });
-    Reception.belongsToMany(Trait, {
-        as: 'Traits',
-        through: EventTrait,
-        foreignKey: 'event_id',
-        otherKey: 'trait_id'
-    });
-    Reception.hasMany(EventTrait, { as: 'EventTraits', foreignKey: 'event_id' });
+    Reception.hasMany(EventTrait, { as: 'EventTraits', foreignKey: 'reception_id' });
     Score.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
     Score.belongsTo(Rally, { as: 'rally', foreignKey: 'rally_id' });
     Score.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
@@ -197,31 +184,13 @@ function initModels(sequelize) {
     SeasonTeams.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
     Serve.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
     Serve.belongsTo(Rally, { as: 'rally', foreignKey: 'rally_id' });
-    Serve.belongsToMany(Trait, {
-        as: 'Traits',
-        through: EventTrait,
-        foreignKey: 'event_id',
-        otherKey: 'trait_id'
-    });
-    Serve.hasMany(EventTrait, { as: 'EventTraits', foreignKey: 'event_id' });
+    Serve.hasMany(EventTrait, { as: 'EventTraits', foreignKey: 'serve_id' });
     Set.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
     Set.belongsTo(Rally, { as: 'rally', foreignKey: 'rally_id' });
-    Set.belongsToMany(Trait, {
-        as: 'Traits',
-        through: EventTrait,
-        foreignKey: 'event_id',
-        otherKey: 'trait_id'
-    });
-    Set.hasMany(EventTrait, { as: 'EventTraits', foreignKey: 'event_id' });
+    Set.hasMany(EventTrait, { as: 'EventTraits', foreignKey: 'set_id' });
     Spike.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
     Spike.belongsTo(Rally, { as: 'rally', foreignKey: 'rally_id' });
-    Spike.belongsToMany(Trait, {
-        as: 'Traits',
-        through: EventTrait,
-        foreignKey: 'event_id',
-        otherKey: 'trait_id'
-    });
-    Spike.hasMany(EventTrait, { as: 'EventTraits', foreignKey: 'event_id' });
+    Spike.hasMany(EventTrait, { as: 'EventTraits', foreignKey: 'spike_id' });
     Substitution.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
     Substitution.belongsTo(Player, { as: 'playerOut', foreignKey: 'player_out' });
     Substitution.belongsTo(Rally, { as: 'rally', foreignKey: 'rally_id' });
@@ -271,12 +240,6 @@ function initModels(sequelize) {
     TournamentMatch.belongsTo(Tournament, { as: 'tournament', foreignKey: 'tournament_id' });
     TournamentTeams.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
     TournamentTeams.belongsTo(Tournament, { as: 'tournament', foreignKey: 'tournament_id' });
-    Trait.belongsToMany(Event, {
-        as: 'Events',
-        through: EventTrait,
-        foreignKey: 'trait_id',
-        otherKey: 'event_id'
-    });
     Trait.belongsToMany(Player, {
         as: 'Players',
         through: PlayerTrait,

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

@@ -37,6 +37,7 @@ export declare class BlockModel extends Model<BlockAttributes, BlockCreationAttr
     blocker_3?: string;
     modifier: number;
     score: number;
+    EventTraits: EventTraitModel[];
     player: PlayerModel;
     getPlayer: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
     setPlayer: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;
@@ -68,7 +69,6 @@ export declare class BlockModel extends Model<BlockAttributes, BlockCreationAttr
     hasTrait: Sequelize.BelongsToManyHasAssociationMixin<TraitModel, TraitId>;
     hasTraits: Sequelize.BelongsToManyHasAssociationsMixin<TraitModel, TraitId>;
     countTraits: Sequelize.BelongsToManyCountAssociationsMixin;
-    EventTraits: EventTraitModel[];
     getEventTraits: Sequelize.HasManyGetAssociationsMixin<EventTraitModel>;
     setEventTraits: Sequelize.HasManySetAssociationsMixin<EventTraitModel, EventTraitId>;
     addEventTrait: Sequelize.HasManyAddAssociationMixin<EventTraitModel, EventTraitId>;

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

@@ -1,21 +1,48 @@
 import * as Sequelize from 'sequelize';
-import { Model } from 'sequelize';
-import type { EventId, EventModel, TraitId, TraitModel } from '.';
+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 EventTraitPk = 'event_id';
 export type EventTraitId = EventTraitModel[EventTraitPk];
-export type EventTraitCreationAttributes = EventTraitAttributes;
+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;
-    event: EventModel;
-    getEvent: Sequelize.BelongsToGetAssociationMixin<EventModel>;
-    setEvent: Sequelize.BelongsToSetAssociationMixin<EventModel, EventId>;
-    createEvent: Sequelize.BelongsToCreateAssociationMixin<EventModel>;
-    trait: TraitModel;
+    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>;

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

@@ -5,19 +5,54 @@ const sequelize_1 = require("sequelize");
 class EventTraitModel extends sequelize_1.Model {
     static initModel(sequelize) {
         return EventTraitModel.init({
-            event_id: {
+            block_id: {
                 type: sequelize_1.DataTypes.UUID,
-                allowNull: false,
-                primaryKey: true,
+                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: 'Event',
+                    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,
-                primaryKey: true,
                 references: {
                     model: 'Trait',
                     key: 'trait_id'
@@ -31,10 +66,7 @@ class EventTraitModel extends sequelize_1.Model {
             indexes: [{
                     name: 'eventtrait_pk',
                     unique: true,
-                    fields: [
-                        { name: 'event_id' },
-                        { name: 'trait_id' },
-                    ]
+                    fields: [{ name: 'event_id' }]
                 }]
         });
     }

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

@@ -1,6 +1,6 @@
 import * as Sequelize from 'sequelize';
 import { Model } from 'sequelize';
-import { PlayerId, PlayerModel, RallyId, RallyModel, TraitId, TraitModel } from '.';
+import { PlayerId, PlayerModel, RallyId, RallyModel } from '.';
 export interface EventAttributes {
     event_id: string;
     rally_id: string;
@@ -27,16 +27,5 @@ export declare class EventModel extends Model<EventAttributes, EventCreationAttr
     getRally: Sequelize.BelongsToGetAssociationMixin<RallyModel>;
     setRally: Sequelize.BelongsToSetAssociationMixin<RallyModel, RallyId>;
     createRally: Sequelize.BelongsToCreateAssociationMixin<RallyModel>;
-    Traits: TraitModel[];
-    getTraits: Sequelize.BelongsToManyGetAssociationsMixin<TraitModel>;
-    setTraits: Sequelize.BelongsToManySetAssociationsMixin<TraitModel, TraitId>;
-    addTrait: Sequelize.BelongsToManyAddAssociationMixin<TraitModel, TraitId>;
-    addTraits: Sequelize.BelongsToManyAddAssociationsMixin<TraitModel, TraitId>;
-    createTrait: Sequelize.BelongsToManyCreateAssociationMixin<TraitModel>;
-    removeTrait: Sequelize.BelongsToManyRemoveAssociationMixin<TraitModel, TraitId>;
-    removeTraits: Sequelize.BelongsToManyRemoveAssociationsMixin<TraitModel, TraitId>;
-    hasTrait: Sequelize.BelongsToManyHasAssociationMixin<TraitModel, TraitId>;
-    hasTraits: Sequelize.BelongsToManyHasAssociationsMixin<TraitModel, TraitId>;
-    countTraits: Sequelize.BelongsToManyCountAssociationsMixin;
     static initModel(sequelize: Sequelize.Sequelize): typeof EventModel;
 }

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

@@ -30,6 +30,7 @@ export declare class ReceptionModel extends Model<ReceptionAttributes, Reception
     player_id: string;
     modifier: number;
     score: number;
+    EventTraits: EventTraitModel[];
     player: PlayerModel;
     getPlayer: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
     setPlayer: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;
@@ -49,7 +50,6 @@ export declare class ReceptionModel extends Model<ReceptionAttributes, Reception
     hasTrait: Sequelize.BelongsToManyHasAssociationMixin<TraitModel, TraitId>;
     hasTraits: Sequelize.BelongsToManyHasAssociationsMixin<TraitModel, TraitId>;
     countTraits: Sequelize.BelongsToManyCountAssociationsMixin;
-    EventTraits: EventTraitModel[];
     getEventTraits: Sequelize.HasManyGetAssociationsMixin<EventTraitModel>;
     setEventTraits: Sequelize.HasManySetAssociationsMixin<EventTraitModel, EventTraitId>;
     addEventTrait: Sequelize.HasManyAddAssociationMixin<EventTraitModel, EventTraitId>;

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

@@ -30,6 +30,7 @@ export declare class ServeModel extends Model<ServeAttributes, ServeCreationAttr
     modifier: number;
     score: number;
     type: ServeType;
+    EventTraits: EventTraitModel[];
     player: PlayerModel;
     getPlayer: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
     setPlayer: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;
@@ -49,7 +50,6 @@ export declare class ServeModel extends Model<ServeAttributes, ServeCreationAttr
     hasTrait: Sequelize.BelongsToManyHasAssociationMixin<TraitModel, TraitId>;
     hasTraits: Sequelize.BelongsToManyHasAssociationsMixin<TraitModel, TraitId>;
     countTraits: Sequelize.BelongsToManyCountAssociationsMixin;
-    EventTraits: EventTraitModel[];
     getEventTraits: Sequelize.HasManyGetAssociationsMixin<EventTraitModel>;
     setEventTraits: Sequelize.HasManySetAssociationsMixin<EventTraitModel, EventTraitId>;
     addEventTrait: Sequelize.HasManyAddAssociationMixin<EventTraitModel, EventTraitId>;

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

@@ -30,6 +30,7 @@ export declare class SetModel extends Model<SetAttributes, SetCreationAttributes
     player_id: string;
     modifier: number;
     score: number;
+    EventTraits: EventTraitModel[];
     player: PlayerModel;
     getPlayer: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
     setPlayer: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;
@@ -49,7 +50,6 @@ export declare class SetModel extends Model<SetAttributes, SetCreationAttributes
     hasTrait: Sequelize.BelongsToManyHasAssociationMixin<TraitModel, TraitId>;
     hasTraits: Sequelize.BelongsToManyHasAssociationsMixin<TraitModel, TraitId>;
     countTraits: Sequelize.BelongsToManyCountAssociationsMixin;
-    EventTraits: EventTraitModel[];
     getEventTraits: Sequelize.HasManyGetAssociationsMixin<EventTraitModel>;
     setEventTraits: Sequelize.HasManySetAssociationsMixin<EventTraitModel, EventTraitId>;
     addEventTrait: Sequelize.HasManyAddAssociationMixin<EventTraitModel, EventTraitId>;

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

@@ -30,6 +30,7 @@ export declare class SpikeModel extends Model<SpikeAttributes, SpikeCreationAttr
     player_id: string;
     modifier: number;
     score: number;
+    EventTraits: EventTraitModel[];
     player: PlayerModel;
     getPlayer: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
     setPlayer: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;
@@ -49,7 +50,6 @@ export declare class SpikeModel extends Model<SpikeAttributes, SpikeCreationAttr
     hasTrait: Sequelize.BelongsToManyHasAssociationMixin<TraitModel, TraitId>;
     hasTraits: Sequelize.BelongsToManyHasAssociationsMixin<TraitModel, TraitId>;
     countTraits: Sequelize.BelongsToManyCountAssociationsMixin;
-    EventTraits: EventTraitModel[];
     getEventTraits: Sequelize.HasManyGetAssociationsMixin<EventTraitModel>;
     setEventTraits: Sequelize.HasManySetAssociationsMixin<EventTraitModel, EventTraitId>;
     addEventTrait: Sequelize.HasManyAddAssociationMixin<EventTraitModel, EventTraitId>;

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

@@ -1,6 +1,6 @@
 import * as Sequelize from 'sequelize';
 import { Model } from 'sequelize';
-import { EventId, EventModel, EventTraitId, EventTraitModel, PlayerId, PlayerModel, PlayerTraitId, PlayerTraitModel } from '.';
+import { EventTraitId, EventTraitModel, PlayerId, PlayerModel, PlayerTraitId, PlayerTraitModel } from '.';
 export interface TraitAttributes {
     trait_id: string;
     name: string;
@@ -22,17 +22,6 @@ export declare class TraitModel extends Model<TraitAttributes, TraitCreationAttr
     threshold: number;
     weight: number;
     general_stat: GeneralStatType;
-    Events: EventModel[];
-    getEvents: Sequelize.BelongsToManyGetAssociationsMixin<EventModel>;
-    setEvents: Sequelize.BelongsToManySetAssociationsMixin<EventModel, EventId>;
-    addEvent: Sequelize.BelongsToManyAddAssociationMixin<EventModel, EventId>;
-    addEvents: Sequelize.BelongsToManyAddAssociationsMixin<EventModel, EventId>;
-    createEvent: Sequelize.BelongsToManyCreateAssociationMixin<EventModel>;
-    removeEvent: Sequelize.BelongsToManyRemoveAssociationMixin<EventModel, EventId>;
-    removeEvents: Sequelize.BelongsToManyRemoveAssociationsMixin<EventModel, EventId>;
-    hasEvent: Sequelize.BelongsToManyHasAssociationMixin<EventModel, EventId>;
-    hasEvents: Sequelize.BelongsToManyHasAssociationsMixin<EventModel, EventId>;
-    countEvents: Sequelize.BelongsToManyCountAssociationsMixin;
     EventTraits: EventTraitModel[];
     getEventTraits: Sequelize.HasManyGetAssociationsMixin<EventTraitModel>;
     setEventTraits: Sequelize.HasManySetAssociationsMixin<EventTraitModel, EventTraitId>;

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

@@ -42,6 +42,11 @@ function transformFromBlockType(type) {
     return service_1.BlockTypeEnum[type];
 }
 function transformToAttributes(event, rallyId) {
+    const eventTraits = event.activeTraits.map(trait => ({
+        block_id: event.id,
+        trait_id: trait.id,
+        event_id: event.id
+    }));
     return {
         event_id: event.id,
         player_id: event.player.id,
@@ -55,7 +60,8 @@ function transformToAttributes(event, rallyId) {
         event_type: (0, _1.transformFromEventType)(event.eventType),
         blocker_1: event.blockers[0]?.id,
         blocker_2: event.blockers[1]?.id,
-        blocker_3: event.blockers[2]?.id
+        blocker_3: event.blockers[2]?.id,
+        EventTraits: eventTraits
     };
 }
 exports.transformFromBlock = transformToAttributes;
@@ -71,7 +77,7 @@ function transformToObject(model) {
         order: model.order,
         score: model.score,
         blockers: [],
-        activeTraits: []
+        activeTraits: model.Traits.map(_1.transformToTrait)
     });
     if (model.Blocker_1 != null)
         block.blockers.push((0, _1.transformToPlayer)(model.Blocker_1));

package/dist/cjs/src/data/transformers/reception.d.ts

@@ -2,6 +2,6 @@ import { Reception } from '../../service';
 import { ReceptionAttributes, ReceptionModel } from '../models';
 import { APIReception } from '../../api';
 declare function transformToAttributes(event: Reception, rallyId: string): ReceptionAttributes;
-declare function transformToObject(event: ReceptionModel): Reception;
+declare function transformToObject(reception: ReceptionModel): Reception;
 declare function transformToAPIObject(event: ReceptionModel): APIReception;
 export { transformToObject as transformToReception, transformToAPIObject as transformToAPIReception, transformToAttributes as transformFromReception };

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

@@ -40,6 +40,11 @@ function transformFromReceptionType(type) {
     return service_1.ReceptionTypeEnum[type];
 }
 function transformToAttributes(event, rallyId) {
+    const eventTraits = event.activeTraits.map(trait => ({
+        event_id: event.id,
+        reception_id: event.id,
+        trait_id: trait.id
+    }));
     return {
         event_id: event.id,
         player_id: event.player.id,
@@ -50,22 +55,23 @@ function transformToAttributes(event, rallyId) {
         target: (0, _1.transformFromCourtTarget)(event.target),
         failure: transformToReceptionFailure(event.failure),
         type: transformToReceptionType(event.type),
-        event_type: (0, _1.transformFromEventType)(event.eventType)
+        event_type: (0, _1.transformFromEventType)(event.eventType),
+        EventTraits: eventTraits
     };
 }
 exports.transformFromReception = transformToAttributes;
-function transformToObject(event) {
+function transformToObject(reception) {
     return new service_1.Reception({
-        id: event.event_id,
-        eventType: (0, _1.transformToEventType)(event.event_type),
-        failure: transformFromReceptionFailure(event.failure),
-        type: transformFromReceptionType(event.type),
-        player: (0, _1.transformToPlayer)(event.player),
-        target: (0, _1.transformToCourtTarget)(event.target),
-        modifier: event.modifier,
-        order: event.order,
-        score: event.score,
-        activeTraits: []
+        id: reception.event_id,
+        eventType: (0, _1.transformToEventType)(reception.event_type),
+        failure: transformFromReceptionFailure(reception.failure),
+        type: transformFromReceptionType(reception.type),
+        player: (0, _1.transformToPlayer)(reception.player),
+        target: (0, _1.transformToCourtTarget)(reception.target),
+        modifier: reception.modifier,
+        order: reception.order,
+        score: reception.score,
+        activeTraits: reception.Traits.map(_1.transformToTrait)
     });
 }
 exports.transformToReception = transformToObject;

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

@@ -42,6 +42,11 @@ function transformFromServeType(type) {
     return service_1.ServeTypeEnum[type];
 }
 function transformToAttributes(event, rallyId) {
+    const eventTraits = event.activeTraits.map(trait => ({
+        event_id: event.id,
+        serve_id: event.id,
+        trait_id: trait.id
+    }));
     return {
         event_id: event.id,
         player_id: event.player.id,
@@ -52,7 +57,8 @@ function transformToAttributes(event, rallyId) {
         target: (0, _1.transformFromCourtTarget)(event.target),
         failure: transformToServeFailure(event.failure),
         type: transformToServeType(event.type),
-        event_type: (0, _1.transformFromEventType)(event.eventType)
+        event_type: (0, _1.transformFromEventType)(event.eventType),
+        EventTraits: eventTraits
     };
 }
 exports.transformFromServe = transformToAttributes;
@@ -67,7 +73,7 @@ function transformToObject(serve) {
         modifier: serve.modifier,
         order: serve.order,
         score: serve.score,
-        activeTraits: []
+        activeTraits: serve.Traits.map(_1.transformToTrait)
     });
 }
 exports.transformToServe = transformToObject;

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

@@ -40,6 +40,11 @@ function transformFromSetType(type) {
     return service_1.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,
@@ -50,7 +55,8 @@ function transformToAttributes(event, rallyId) {
         target: (0, _1.transformFromCourtTarget)(event.target),
         failure: transformToSetFailure(event.failure),
         type: transformToSetType(event.type),
-        event_type: (0, _1.transformFromEventType)(event.eventType)
+        event_type: (0, _1.transformFromEventType)(event.eventType),
+        EventTraits: eventTraits
     };
 }
 exports.transformFromSet = transformToAttributes;
@@ -65,7 +71,7 @@ function transformToObject(set) {
         modifier: set.modifier,
         order: set.order,
         score: set.score,
-        activeTraits: []
+        activeTraits: set.Traits.map(_1.transformToTrait)
     });
 }
 exports.transformToSet = transformToObject;

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

@@ -44,6 +44,11 @@ function transformFromSpikeType(type) {
     return service_1.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,
@@ -54,7 +59,8 @@ function transformToAttributes(event, rallyId) {
         target: (0, _1.transformFromCourtTarget)(event.target),
         failure: transformToSpikeFailure(event.failure),
         type: transformToSpikeType(event.type),
-        event_type: (0, _1.transformFromEventType)(event.eventType)
+        event_type: (0, _1.transformFromEventType)(event.eventType),
+        EventTraits: eventTraits
     };
 }
 exports.transformFromSpike = transformToAttributes;
@@ -69,7 +75,7 @@ function transformToObject(spike) {
         modifier: spike.modifier,
         order: spike.order,
         score: spike.score,
-        activeTraits: []
+        activeTraits: spike.Traits.map(_1.transformToTrait)
     });
 }
 exports.transformToSpike = transformToObject;

package/dist/esm/src/data/init-models.js

@@ -44,13 +44,7 @@ export function initModels(sequelize) {
     Block.belongsTo(Player, { as: 'Blocker_3', foreignKey: 'blocker_3' });
     Block.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
     Block.belongsTo(Rally, { as: 'rally', foreignKey: 'rally_id' });
-    Block.belongsToMany(Trait, {
-        as: 'Traits',
-        through: EventTrait,
-        foreignKey: 'event_id',
-        otherKey: 'trait_id'
-    });
-    Block.hasMany(EventTrait, { as: 'EventTraits', foreignKey: 'event_id' });
+    Block.hasMany(EventTrait, { as: 'EventTraits', foreignKey: 'block_id' });
     Coach.belongsTo(Country, { as: 'country', foreignKey: 'country_id' });
     Coach.hasMany(Team, { as: 'Teams', foreignKey: 'coach_id' });
     Country.hasMany(Coach, { as: 'Coaches', foreignKey: 'country_id' });
@@ -59,13 +53,12 @@ export function initModels(sequelize) {
     Country.hasMany(Team, { as: 'Teams', foreignKey: 'country_id' });
     Event.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
     Event.belongsTo(Rally, { as: 'rally', foreignKey: 'rally_id' });
-    Event.belongsToMany(Trait, {
-        as: 'Traits',
-        through: EventTrait,
-        foreignKey: 'event_id',
-        otherKey: 'trait_id'
-    });
-    EventTrait.belongsTo(Trait, { as: 'trait', foreignKey: 'trait_id' });
+    EventTrait.belongsTo(Block, { as: 'Block', foreignKey: 'block_id' });
+    EventTrait.belongsTo(Reception, { as: 'Reception', foreignKey: 'reception_id' });
+    EventTrait.belongsTo(Serve, { as: 'Serve', foreignKey: 'serve_id' });
+    EventTrait.belongsTo(Set, { as: 'Set', foreignKey: 'set_id' });
+    EventTrait.belongsTo(Spike, { as: 'Spike', foreignKey: 'spike_id' });
+    EventTrait.belongsTo(Trait, { as: 'Trait', foreignKey: 'trait_id' });
     Iteration.hasMany(Season, { as: 'Seasons', foreignKey: 'iteration' });
     Iteration.hasOne(Tournament, { as: 'Tournament', foreignKey: 'iteration' });
     League.belongsTo(Country, { as: 'country', foreignKey: 'country_id' });
@@ -167,13 +160,7 @@ export function initModels(sequelize) {
     RallyPosition.belongsTo(Rally, { as: 'rally', foreignKey: 'rally_id' });
     Reception.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
     Reception.belongsTo(Rally, { as: 'rally', foreignKey: 'rally_id' });
-    Reception.belongsToMany(Trait, {
-        as: 'Traits',
-        through: EventTrait,
-        foreignKey: 'event_id',
-        otherKey: 'trait_id'
-    });
-    Reception.hasMany(EventTrait, { as: 'EventTraits', foreignKey: 'event_id' });
+    Reception.hasMany(EventTrait, { as: 'EventTraits', foreignKey: 'reception_id' });
     Score.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
     Score.belongsTo(Rally, { as: 'rally', foreignKey: 'rally_id' });
     Score.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
@@ -194,31 +181,13 @@ export function initModels(sequelize) {
     SeasonTeams.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
     Serve.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
     Serve.belongsTo(Rally, { as: 'rally', foreignKey: 'rally_id' });
-    Serve.belongsToMany(Trait, {
-        as: 'Traits',
-        through: EventTrait,
-        foreignKey: 'event_id',
-        otherKey: 'trait_id'
-    });
-    Serve.hasMany(EventTrait, { as: 'EventTraits', foreignKey: 'event_id' });
+    Serve.hasMany(EventTrait, { as: 'EventTraits', foreignKey: 'serve_id' });
     Set.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
     Set.belongsTo(Rally, { as: 'rally', foreignKey: 'rally_id' });
-    Set.belongsToMany(Trait, {
-        as: 'Traits',
-        through: EventTrait,
-        foreignKey: 'event_id',
-        otherKey: 'trait_id'
-    });
-    Set.hasMany(EventTrait, { as: 'EventTraits', foreignKey: 'event_id' });
+    Set.hasMany(EventTrait, { as: 'EventTraits', foreignKey: 'set_id' });
     Spike.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
     Spike.belongsTo(Rally, { as: 'rally', foreignKey: 'rally_id' });
-    Spike.belongsToMany(Trait, {
-        as: 'Traits',
-        through: EventTrait,
-        foreignKey: 'event_id',
-        otherKey: 'trait_id'
-    });
-    Spike.hasMany(EventTrait, { as: 'EventTraits', foreignKey: 'event_id' });
+    Spike.hasMany(EventTrait, { as: 'EventTraits', foreignKey: 'spike_id' });
     Substitution.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
     Substitution.belongsTo(Player, { as: 'playerOut', foreignKey: 'player_out' });
     Substitution.belongsTo(Rally, { as: 'rally', foreignKey: 'rally_id' });
@@ -268,12 +237,6 @@ export function initModels(sequelize) {
     TournamentMatch.belongsTo(Tournament, { as: 'tournament', foreignKey: 'tournament_id' });
     TournamentTeams.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
     TournamentTeams.belongsTo(Tournament, { as: 'tournament', foreignKey: 'tournament_id' });
-    Trait.belongsToMany(Event, {
-        as: 'Events',
-        through: EventTrait,
-        foreignKey: 'trait_id',
-        otherKey: 'event_id'
-    });
     Trait.belongsToMany(Player, {
         as: 'Players',
         through: PlayerTrait,

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

@@ -37,6 +37,7 @@ export declare class BlockModel extends Model<BlockAttributes, BlockCreationAttr
     blocker_3?: string;
     modifier: number;
     score: number;
+    EventTraits: EventTraitModel[];
     player: PlayerModel;
     getPlayer: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
     setPlayer: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;
@@ -68,7 +69,6 @@ export declare class BlockModel extends Model<BlockAttributes, BlockCreationAttr
     hasTrait: Sequelize.BelongsToManyHasAssociationMixin<TraitModel, TraitId>;
     hasTraits: Sequelize.BelongsToManyHasAssociationsMixin<TraitModel, TraitId>;
     countTraits: Sequelize.BelongsToManyCountAssociationsMixin;
-    EventTraits: EventTraitModel[];
     getEventTraits: Sequelize.HasManyGetAssociationsMixin<EventTraitModel>;
     setEventTraits: Sequelize.HasManySetAssociationsMixin<EventTraitModel, EventTraitId>;
     addEventTrait: Sequelize.HasManyAddAssociationMixin<EventTraitModel, EventTraitId>;

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

@@ -1,21 +1,48 @@
 import * as Sequelize from 'sequelize';
-import { Model } from 'sequelize';
-import type { EventId, EventModel, TraitId, TraitModel } from '.';
+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 EventTraitPk = 'event_id';
 export type EventTraitId = EventTraitModel[EventTraitPk];
-export type EventTraitCreationAttributes = EventTraitAttributes;
+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;
-    event: EventModel;
-    getEvent: Sequelize.BelongsToGetAssociationMixin<EventModel>;
-    setEvent: Sequelize.BelongsToSetAssociationMixin<EventModel, EventId>;
-    createEvent: Sequelize.BelongsToCreateAssociationMixin<EventModel>;
-    trait: TraitModel;
+    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>;

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

@@ -2,19 +2,54 @@ import { DataTypes, Model } from 'sequelize';
 export class EventTraitModel extends Model {
     static initModel(sequelize) {
         return EventTraitModel.init({
-            event_id: {
+            block_id: {
                 type: DataTypes.UUID,
-                allowNull: false,
-                primaryKey: true,
+                allowNull: true,
+                references: {
+                    model: 'Block',
+                    key: 'event_id'
+                }
+            },
+            reception_id: {
+                type: DataTypes.UUID,
+                allowNull: true,
+                references: {
+                    model: 'Reception',
+                    key: 'event_id'
+                }
+            },
+            serve_id: {
+                type: DataTypes.UUID,
+                allowNull: true,
+                references: {
+                    model: 'Serve',
+                    key: 'event_id'
+                }
+            },
+            set_id: {
+                type: DataTypes.UUID,
+                allowNull: true,
                 references: {
-                    model: 'Event',
+                    model: 'Set',
                     key: 'event_id'
                 }
             },
+            spike_id: {
+                type: DataTypes.UUID,
+                allowNull: true,
+                references: {
+                    model: 'Spike',
+                    key: 'event_id'
+                }
+            },
+            event_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true
+            },
             trait_id: {
                 type: DataTypes.UUID,
                 allowNull: false,
-                primaryKey: true,
                 references: {
                     model: 'Trait',
                     key: 'trait_id'
@@ -28,10 +63,7 @@ export class EventTraitModel extends Model {
             indexes: [{
                     name: 'eventtrait_pk',
                     unique: true,
-                    fields: [
-                        { name: 'event_id' },
-                        { name: 'trait_id' },
-                    ]
+                    fields: [{ name: 'event_id' }]
                 }]
         });
     }

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

@@ -1,6 +1,6 @@
 import * as Sequelize from 'sequelize';
 import { Model } from 'sequelize';
-import { PlayerId, PlayerModel, RallyId, RallyModel, TraitId, TraitModel } from '.';
+import { PlayerId, PlayerModel, RallyId, RallyModel } from '.';
 export interface EventAttributes {
     event_id: string;
     rally_id: string;
@@ -27,16 +27,5 @@ export declare class EventModel extends Model<EventAttributes, EventCreationAttr
     getRally: Sequelize.BelongsToGetAssociationMixin<RallyModel>;
     setRally: Sequelize.BelongsToSetAssociationMixin<RallyModel, RallyId>;
     createRally: Sequelize.BelongsToCreateAssociationMixin<RallyModel>;
-    Traits: TraitModel[];
-    getTraits: Sequelize.BelongsToManyGetAssociationsMixin<TraitModel>;
-    setTraits: Sequelize.BelongsToManySetAssociationsMixin<TraitModel, TraitId>;
-    addTrait: Sequelize.BelongsToManyAddAssociationMixin<TraitModel, TraitId>;
-    addTraits: Sequelize.BelongsToManyAddAssociationsMixin<TraitModel, TraitId>;
-    createTrait: Sequelize.BelongsToManyCreateAssociationMixin<TraitModel>;
-    removeTrait: Sequelize.BelongsToManyRemoveAssociationMixin<TraitModel, TraitId>;
-    removeTraits: Sequelize.BelongsToManyRemoveAssociationsMixin<TraitModel, TraitId>;
-    hasTrait: Sequelize.BelongsToManyHasAssociationMixin<TraitModel, TraitId>;
-    hasTraits: Sequelize.BelongsToManyHasAssociationsMixin<TraitModel, TraitId>;
-    countTraits: Sequelize.BelongsToManyCountAssociationsMixin;
     static initModel(sequelize: Sequelize.Sequelize): typeof EventModel;
 }

package/dist/esm/src/data/models/reception.d.ts

@@ -30,6 +30,7 @@ export declare class ReceptionModel extends Model<ReceptionAttributes, Reception
     player_id: string;
     modifier: number;
     score: number;
+    EventTraits: EventTraitModel[];
     player: PlayerModel;
     getPlayer: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
     setPlayer: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;
@@ -49,7 +50,6 @@ export declare class ReceptionModel extends Model<ReceptionAttributes, Reception
     hasTrait: Sequelize.BelongsToManyHasAssociationMixin<TraitModel, TraitId>;
     hasTraits: Sequelize.BelongsToManyHasAssociationsMixin<TraitModel, TraitId>;
     countTraits: Sequelize.BelongsToManyCountAssociationsMixin;
-    EventTraits: EventTraitModel[];
     getEventTraits: Sequelize.HasManyGetAssociationsMixin<EventTraitModel>;
     setEventTraits: Sequelize.HasManySetAssociationsMixin<EventTraitModel, EventTraitId>;
     addEventTrait: Sequelize.HasManyAddAssociationMixin<EventTraitModel, EventTraitId>;

package/dist/esm/src/data/models/serve.d.ts

@@ -30,6 +30,7 @@ export declare class ServeModel extends Model<ServeAttributes, ServeCreationAttr
     modifier: number;
     score: number;
     type: ServeType;
+    EventTraits: EventTraitModel[];
     player: PlayerModel;
     getPlayer: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
     setPlayer: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;
@@ -49,7 +50,6 @@ export declare class ServeModel extends Model<ServeAttributes, ServeCreationAttr
     hasTrait: Sequelize.BelongsToManyHasAssociationMixin<TraitModel, TraitId>;
     hasTraits: Sequelize.BelongsToManyHasAssociationsMixin<TraitModel, TraitId>;
     countTraits: Sequelize.BelongsToManyCountAssociationsMixin;
-    EventTraits: EventTraitModel[];
     getEventTraits: Sequelize.HasManyGetAssociationsMixin<EventTraitModel>;
     setEventTraits: Sequelize.HasManySetAssociationsMixin<EventTraitModel, EventTraitId>;
     addEventTrait: Sequelize.HasManyAddAssociationMixin<EventTraitModel, EventTraitId>;

package/dist/esm/src/data/models/set.d.ts

@@ -30,6 +30,7 @@ export declare class SetModel extends Model<SetAttributes, SetCreationAttributes
     player_id: string;
     modifier: number;
     score: number;
+    EventTraits: EventTraitModel[];
     player: PlayerModel;
     getPlayer: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
     setPlayer: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;
@@ -49,7 +50,6 @@ export declare class SetModel extends Model<SetAttributes, SetCreationAttributes
     hasTrait: Sequelize.BelongsToManyHasAssociationMixin<TraitModel, TraitId>;
     hasTraits: Sequelize.BelongsToManyHasAssociationsMixin<TraitModel, TraitId>;
     countTraits: Sequelize.BelongsToManyCountAssociationsMixin;
-    EventTraits: EventTraitModel[];
     getEventTraits: Sequelize.HasManyGetAssociationsMixin<EventTraitModel>;
     setEventTraits: Sequelize.HasManySetAssociationsMixin<EventTraitModel, EventTraitId>;
     addEventTrait: Sequelize.HasManyAddAssociationMixin<EventTraitModel, EventTraitId>;

package/dist/esm/src/data/models/spike.d.ts

@@ -30,6 +30,7 @@ export declare class SpikeModel extends Model<SpikeAttributes, SpikeCreationAttr
     player_id: string;
     modifier: number;
     score: number;
+    EventTraits: EventTraitModel[];
     player: PlayerModel;
     getPlayer: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
     setPlayer: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;
@@ -49,7 +50,6 @@ export declare class SpikeModel extends Model<SpikeAttributes, SpikeCreationAttr
     hasTrait: Sequelize.BelongsToManyHasAssociationMixin<TraitModel, TraitId>;
     hasTraits: Sequelize.BelongsToManyHasAssociationsMixin<TraitModel, TraitId>;
     countTraits: Sequelize.BelongsToManyCountAssociationsMixin;
-    EventTraits: EventTraitModel[];
     getEventTraits: Sequelize.HasManyGetAssociationsMixin<EventTraitModel>;
     setEventTraits: Sequelize.HasManySetAssociationsMixin<EventTraitModel, EventTraitId>;
     addEventTrait: Sequelize.HasManyAddAssociationMixin<EventTraitModel, EventTraitId>;

package/dist/esm/src/data/models/trait.d.ts

@@ -1,6 +1,6 @@
 import * as Sequelize from 'sequelize';
 import { Model } from 'sequelize';
-import { EventId, EventModel, EventTraitId, EventTraitModel, PlayerId, PlayerModel, PlayerTraitId, PlayerTraitModel } from '.';
+import { EventTraitId, EventTraitModel, PlayerId, PlayerModel, PlayerTraitId, PlayerTraitModel } from '.';
 export interface TraitAttributes {
     trait_id: string;
     name: string;
@@ -22,17 +22,6 @@ export declare class TraitModel extends Model<TraitAttributes, TraitCreationAttr
     threshold: number;
     weight: number;
     general_stat: GeneralStatType;
-    Events: EventModel[];
-    getEvents: Sequelize.BelongsToManyGetAssociationsMixin<EventModel>;
-    setEvents: Sequelize.BelongsToManySetAssociationsMixin<EventModel, EventId>;
-    addEvent: Sequelize.BelongsToManyAddAssociationMixin<EventModel, EventId>;
-    addEvents: Sequelize.BelongsToManyAddAssociationsMixin<EventModel, EventId>;
-    createEvent: Sequelize.BelongsToManyCreateAssociationMixin<EventModel>;
-    removeEvent: Sequelize.BelongsToManyRemoveAssociationMixin<EventModel, EventId>;
-    removeEvents: Sequelize.BelongsToManyRemoveAssociationsMixin<EventModel, EventId>;
-    hasEvent: Sequelize.BelongsToManyHasAssociationMixin<EventModel, EventId>;
-    hasEvents: Sequelize.BelongsToManyHasAssociationsMixin<EventModel, EventId>;
-    countEvents: Sequelize.BelongsToManyCountAssociationsMixin;
     EventTraits: EventTraitModel[];
     getEventTraits: Sequelize.HasManyGetAssociationsMixin<EventTraitModel>;
     setEventTraits: Sequelize.HasManySetAssociationsMixin<EventTraitModel, EventTraitId>;

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

@@ -1,5 +1,5 @@
 import { Block, BlockFailureEnum, BlockTypeEnum } from '../../service';
-import { transformFromCourtTarget, transformFromEventType, transformToCourtTarget, transformToEventType, transformToPlayer } from '.';
+import { transformFromCourtTarget, transformFromEventType, transformToCourtTarget, transformToEventType, transformToPlayer, transformToTrait } from '.';
 function transformToBlockFailure(failure) {
     switch (failure) {
         case BlockFailureEnum.NO_FAILURE:
@@ -39,6 +39,11 @@ function transformFromBlockType(type) {
     return BlockTypeEnum[type];
 }
 function transformToAttributes(event, rallyId) {
+    const eventTraits = event.activeTraits.map(trait => ({
+        block_id: event.id,
+        trait_id: trait.id,
+        event_id: event.id
+    }));
     return {
         event_id: event.id,
         player_id: event.player.id,
@@ -52,7 +57,8 @@ function transformToAttributes(event, rallyId) {
         event_type: transformFromEventType(event.eventType),
         blocker_1: event.blockers[0]?.id,
         blocker_2: event.blockers[1]?.id,
-        blocker_3: event.blockers[2]?.id
+        blocker_3: event.blockers[2]?.id,
+        EventTraits: eventTraits
     };
 }
 function transformToObject(model) {
@@ -67,7 +73,7 @@ function transformToObject(model) {
         order: model.order,
         score: model.score,
         blockers: [],
-        activeTraits: []
+        activeTraits: model.Traits.map(transformToTrait)
     });
     if (model.Blocker_1 != null)
         block.blockers.push(transformToPlayer(model.Blocker_1));

package/dist/esm/src/data/transformers/reception.d.ts

@@ -2,6 +2,6 @@ import { Reception } from '../../service';
 import { ReceptionAttributes, ReceptionModel } from '../models';
 import { APIReception } from '../../api';
 declare function transformToAttributes(event: Reception, rallyId: string): ReceptionAttributes;
-declare function transformToObject(event: ReceptionModel): Reception;
+declare function transformToObject(reception: ReceptionModel): Reception;
 declare function transformToAPIObject(event: ReceptionModel): APIReception;
 export { transformToObject as transformToReception, transformToAPIObject as transformToAPIReception, transformToAttributes as transformFromReception };

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

@@ -1,5 +1,5 @@
 import { Reception, ReceptionFailureEnum, ReceptionTypeEnum } from '../../service';
-import { transformFromCourtTarget, transformFromEventType, transformToCourtTarget, transformToEventType, transformToPlayer } from '.';
+import { transformFromCourtTarget, transformFromEventType, transformToCourtTarget, transformToEventType, transformToPlayer, transformToTrait } from '.';
 function transformToReceptionFailure(failure) {
     switch (failure) {
         case ReceptionFailureEnum.NO_FAILURE:
@@ -37,6 +37,11 @@ function transformFromReceptionType(type) {
     return ReceptionTypeEnum[type];
 }
 function transformToAttributes(event, rallyId) {
+    const eventTraits = event.activeTraits.map(trait => ({
+        event_id: event.id,
+        reception_id: event.id,
+        trait_id: trait.id
+    }));
     return {
         event_id: event.id,
         player_id: event.player.id,
@@ -47,21 +52,22 @@ function transformToAttributes(event, rallyId) {
         target: transformFromCourtTarget(event.target),
         failure: transformToReceptionFailure(event.failure),
         type: transformToReceptionType(event.type),
-        event_type: transformFromEventType(event.eventType)
+        event_type: transformFromEventType(event.eventType),
+        EventTraits: eventTraits
     };
 }
-function transformToObject(event) {
+function transformToObject(reception) {
     return new Reception({
-        id: event.event_id,
-        eventType: transformToEventType(event.event_type),
-        failure: transformFromReceptionFailure(event.failure),
-        type: transformFromReceptionType(event.type),
-        player: transformToPlayer(event.player),
-        target: transformToCourtTarget(event.target),
-        modifier: event.modifier,
-        order: event.order,
-        score: event.score,
-        activeTraits: []
+        id: reception.event_id,
+        eventType: transformToEventType(reception.event_type),
+        failure: transformFromReceptionFailure(reception.failure),
+        type: transformFromReceptionType(reception.type),
+        player: transformToPlayer(reception.player),
+        target: transformToCourtTarget(reception.target),
+        modifier: reception.modifier,
+        order: reception.order,
+        score: reception.score,
+        activeTraits: reception.Traits.map(transformToTrait)
     });
 }
 function transformToAPIObject(event) {

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

@@ -1,5 +1,5 @@
 import { Serve, ServeFailureEnum, ServeTypeEnum } from '../../service';
-import { transformFromCourtTarget, transformFromEventType, transformToCourtTarget, transformToEventType, transformToPlayer } from '.';
+import { transformFromCourtTarget, transformFromEventType, transformToCourtTarget, transformToEventType, transformToPlayer, transformToTrait } from '.';
 function transformToServeFailure(failure) {
     switch (failure) {
         case ServeFailureEnum.NO_FAILURE:
@@ -39,6 +39,11 @@ function transformFromServeType(type) {
     return ServeTypeEnum[type];
 }
 function transformToAttributes(event, rallyId) {
+    const eventTraits = event.activeTraits.map(trait => ({
+        event_id: event.id,
+        serve_id: event.id,
+        trait_id: trait.id
+    }));
     return {
         event_id: event.id,
         player_id: event.player.id,
@@ -49,7 +54,8 @@ function transformToAttributes(event, rallyId) {
         target: transformFromCourtTarget(event.target),
         failure: transformToServeFailure(event.failure),
         type: transformToServeType(event.type),
-        event_type: transformFromEventType(event.eventType)
+        event_type: transformFromEventType(event.eventType),
+        EventTraits: eventTraits
     };
 }
 function transformToObject(serve) {
@@ -63,7 +69,7 @@ function transformToObject(serve) {
         modifier: serve.modifier,
         order: serve.order,
         score: serve.score,
-        activeTraits: []
+        activeTraits: serve.Traits.map(transformToTrait)
     });
 }
 function transformToAPIObject(event) {

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

@@ -1,5 +1,5 @@
 import { Set, SetFailureEnum, SetTypeEnum } from '../../service';
-import { transformFromCourtTarget, transformFromEventType, transformToCourtTarget, transformToEventType, transformToPlayer } from '.';
+import { transformFromCourtTarget, transformFromEventType, transformToCourtTarget, transformToEventType, transformToPlayer, transformToTrait } from '.';
 function transformToSetFailure(failure) {
     switch (failure) {
         case SetFailureEnum.NO_FAILURE:
@@ -37,6 +37,11 @@ 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,
@@ -47,7 +52,8 @@ function transformToAttributes(event, rallyId) {
         target: transformFromCourtTarget(event.target),
         failure: transformToSetFailure(event.failure),
         type: transformToSetType(event.type),
-        event_type: transformFromEventType(event.eventType)
+        event_type: transformFromEventType(event.eventType),
+        EventTraits: eventTraits
     };
 }
 function transformToObject(set) {
@@ -61,7 +67,7 @@ function transformToObject(set) {
         modifier: set.modifier,
         order: set.order,
         score: set.score,
-        activeTraits: []
+        activeTraits: set.Traits.map(transformToTrait)
     });
 }
 function transformToAPIObject(event) {

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

@@ -1,5 +1,5 @@
 import { Spike, SpikeFailureEnum, SpikeTypeEnum } from '../../service';
-import { transformFromCourtTarget, transformFromEventType, transformToCourtTarget, transformToEventType, transformToPlayer } from '.';
+import { transformFromCourtTarget, transformFromEventType, transformToCourtTarget, transformToEventType, transformToPlayer, transformToTrait } from '.';
 function transformToSpikeFailure(failure) {
     switch (failure) {
         case SpikeFailureEnum.NO_FAILURE:
@@ -41,6 +41,11 @@ 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,
@@ -51,7 +56,8 @@ function transformToAttributes(event, rallyId) {
         target: transformFromCourtTarget(event.target),
         failure: transformToSpikeFailure(event.failure),
         type: transformToSpikeType(event.type),
-        event_type: transformFromEventType(event.eventType)
+        event_type: transformFromEventType(event.eventType),
+        EventTraits: eventTraits
     };
 }
 function transformToObject(spike) {
@@ -65,7 +71,7 @@ function transformToObject(spike) {
         modifier: spike.modifier,
         order: spike.order,
         score: spike.score,
-        activeTraits: []
+        activeTraits: spike.Traits.map(transformToTrait)
     });
 }
 function transformToAPIObject(event) {

package/package.json

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