volleyballsimtypes 0.0.83 → 0.0.84

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

@@ -1,6 +1,6 @@
 import * as Sequelize from 'sequelize';
 import { Model } from 'sequelize';
-import { CourtTarget, EventType, PlayerId, PlayerModel, RallyId, RallyModel, TraitType } from '.';
+import { CourtTarget, EventType, PlayerId, PlayerModel, RallyId, RallyModel, TraitId, TraitModel } from '.';
 export interface SpikeAttributes {
     event_id: string;
     rally_id: string;
@@ -29,7 +29,6 @@ export declare class SpikeModel extends Model<SpikeAttributes, SpikeCreationAttr
     player_id: string;
     modifier: number;
     score: number;
-    active_traits: TraitType[];
     player: PlayerModel;
     getPlayer: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
     setPlayer: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;
@@ -38,5 +37,16 @@ export declare class SpikeModel extends Model<SpikeAttributes, SpikeCreationAttr
     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 SpikeModel;
 }

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

@@ -26,6 +26,7 @@ export declare class TeamModel extends Model<TeamAttributes, TeamCreationAttribu
     league_id: string;
     country_id: string;
     coach: CoachModel;
+    league: LeagueModel;
     getCoach: Sequelize.BelongsToGetAssociationMixin<CoachModel>;
     setCoach: Sequelize.BelongsToSetAssociationMixin<CoachModel, CoachId>;
     createCoach: Sequelize.BelongsToCreateAssociationMixin<CoachModel>;
@@ -33,7 +34,6 @@ export declare class TeamModel extends Model<TeamAttributes, TeamCreationAttribu
     getCountry: Sequelize.BelongsToGetAssociationMixin<CountryModel>;
     setCountry: Sequelize.BelongsToSetAssociationMixin<CountryModel, CountryId>;
     createCountry: Sequelize.BelongsToCreateAssociationMixin<CountryModel>;
-    league: LeagueModel;
     getLeague: Sequelize.BelongsToGetAssociationMixin<LeagueModel>;
     setLeague: Sequelize.BelongsToSetAssociationMixin<LeagueModel, LeagueId>;
     createLeague: Sequelize.BelongsToCreateAssociationMixin<LeagueModel>;

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

@@ -17,6 +17,7 @@ export declare class TournamentModel extends Model<TournamentAttributes, Tournam
     tournament_id: string;
     iteration: number;
     champion?: string;
+    TournamentMatches: TournamentMatchModel[];
     tournamentTeams: TeamModel[];
     Iteration: IterationModel;
     getIteration: Sequelize.BelongsToGetAssociationMixin<IterationModel>;
@@ -26,7 +27,6 @@ export declare class TournamentModel extends Model<TournamentAttributes, Tournam
     getChampion: Sequelize.BelongsToGetAssociationMixin<TeamModel>;
     setChampion: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>;
     createChampion: Sequelize.BelongsToCreateAssociationMixin<TeamModel>;
-    TournamentMatches: TournamentMatchModel[];
     getTournamentMatches: Sequelize.HasManyGetAssociationsMixin<TournamentMatchModel>;
     setTournamentMatches: Sequelize.HasManySetAssociationsMixin<TournamentMatchModel, TournamentMatchId>;
     addTournamentMatch: Sequelize.HasManyAddAssociationMixin<TournamentMatchModel, TournamentMatchId>;

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

@@ -0,0 +1,70 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { EventId, EventModel, EventTraitId, EventTraitModel, PlayerId, PlayerModel, PlayerTraitId, PlayerTraitModel } from '.';
+export interface TraitAttributes {
+    trait_id: string;
+    name: string;
+    modifier: number;
+    chance: number;
+    threshold: number;
+    weight: number;
+    general_stat: GeneralStatType;
+}
+export type TraitPk = 'trait_id';
+export type TraitId = TraitModel[TraitPk];
+export type TraitCreationAttributes = TraitAttributes;
+export type GeneralStatType = 'Attack' | 'Defense' | 'Physical' | 'Serve';
+export declare class TraitModel extends Model<TraitAttributes, TraitCreationAttributes> implements TraitAttributes {
+    trait_id: string;
+    name: string;
+    modifier: number;
+    chance: number;
+    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>;
+    addEventTrait: Sequelize.HasManyAddAssociationMixin<EventTraitModel, EventTraitId>;
+    addEventTraits: Sequelize.HasManyAddAssociationsMixin<EventTraitModel, EventTraitId>;
+    createEventTrait: Sequelize.HasManyCreateAssociationMixin<EventTraitModel>;
+    removeEventTrait: Sequelize.HasManyRemoveAssociationMixin<EventTraitModel, EventTraitId>;
+    removeEventTraits: Sequelize.HasManyRemoveAssociationsMixin<EventTraitModel, EventTraitId>;
+    hasEventTrait: Sequelize.HasManyHasAssociationMixin<EventTraitModel, EventTraitId>;
+    hasEventTraits: Sequelize.HasManyHasAssociationsMixin<EventTraitModel, EventTraitId>;
+    countEventTraits: Sequelize.HasManyCountAssociationsMixin;
+    Players: PlayerModel[];
+    getPlayers: Sequelize.BelongsToManyGetAssociationsMixin<PlayerModel>;
+    setPlayers: Sequelize.BelongsToManySetAssociationsMixin<PlayerModel, PlayerId>;
+    addPlayer: Sequelize.BelongsToManyAddAssociationMixin<PlayerModel, PlayerId>;
+    addPlayers: Sequelize.BelongsToManyAddAssociationsMixin<PlayerModel, PlayerId>;
+    createPlayer: Sequelize.BelongsToManyCreateAssociationMixin<PlayerModel>;
+    removePlayer: Sequelize.BelongsToManyRemoveAssociationMixin<PlayerModel, PlayerId>;
+    removePlayers: Sequelize.BelongsToManyRemoveAssociationsMixin<PlayerModel, PlayerId>;
+    hasPlayer: Sequelize.BelongsToManyHasAssociationMixin<PlayerModel, PlayerId>;
+    hasPlayers: Sequelize.BelongsToManyHasAssociationsMixin<PlayerModel, PlayerId>;
+    countPlayers: Sequelize.BelongsToManyCountAssociationsMixin;
+    PlayerTraits: PlayerTraitModel[];
+    getPlayerTraits: Sequelize.HasManyGetAssociationsMixin<PlayerTraitModel>;
+    setPlayerTraits: Sequelize.HasManySetAssociationsMixin<PlayerTraitModel, PlayerTraitId>;
+    addPlayerTrait: Sequelize.HasManyAddAssociationMixin<PlayerTraitModel, PlayerTraitId>;
+    addPlayerTraits: Sequelize.HasManyAddAssociationsMixin<PlayerTraitModel, PlayerTraitId>;
+    createPlayerTrait: Sequelize.HasManyCreateAssociationMixin<PlayerTraitModel>;
+    removePlayerTrait: Sequelize.HasManyRemoveAssociationMixin<PlayerTraitModel, PlayerTraitId>;
+    removePlayerTraits: Sequelize.HasManyRemoveAssociationsMixin<PlayerTraitModel, PlayerTraitId>;
+    hasPlayerTrait: Sequelize.HasManyHasAssociationMixin<PlayerTraitModel, PlayerTraitId>;
+    hasPlayerTraits: Sequelize.HasManyHasAssociationsMixin<PlayerTraitModel, PlayerTraitId>;
+    countPlayerTraits: Sequelize.HasManyCountAssociationsMixin;
+    static initModel(sequelize: Sequelize.Sequelize): typeof TraitModel;
+}

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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TraitModel = void 0;
+const sequelize_1 = require("sequelize");
+class TraitModel extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return TraitModel.init({
+            trait_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true
+            },
+            name: {
+                type: sequelize_1.DataTypes.STRING,
+                allowNull: false
+            },
+            modifier: {
+                type: sequelize_1.DataTypes.REAL,
+                allowNull: false
+            },
+            chance: {
+                type: sequelize_1.DataTypes.REAL,
+                allowNull: false
+            },
+            threshold: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false
+            },
+            weight: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false
+            },
+            general_stat: {
+                type: sequelize_1.DataTypes.ENUM('Attack', 'Defense', 'Physical', 'Serve'),
+                allowNull: false
+            }
+        }, {
+            sequelize,
+            tableName: 'Trait',
+            schema: 'public',
+            timestamps: false,
+            indexes: [{
+                    name: 'trait_pk',
+                    unique: true,
+                    fields: [{ name: 'trait_id' }]
+                }]
+        });
+    }
+}
+exports.TraitModel = TraitModel;

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

@@ -9,7 +9,6 @@ function transformToAttributes(player) {
         country_id: player.country.id,
         first_name: player.name.first,
         last_name: player.name.last,
-        traits: player.traits.map(_1.transformFromTrait),
         roles: player.roles.map(_1.transformFromRole),
         PerformanceStat: (0, _1.transformFromPerformanceStats)(player)
     };
@@ -24,7 +23,7 @@ function transformToObject(model) {
         },
         country: (0, _1.transformToCountry)(model.country),
         roles: model.roles.map(_1.transformToRole),
-        traits: model.traits.map(_1.transformToTrait),
+        traits: model.Traits.map(_1.transformToTrait),
         stats: (0, _1.transformToPerformanceStats)(model.PerformanceStat)
     });
 }
@@ -44,7 +43,7 @@ function transformToAPIObject(model) {
         },
         country: (0, _1.transformToCountry)(model.country),
         roles: model.roles.map(_1.transformToRole),
-        traits: model.traits.map(_1.transformToAPITrait),
+        traits: model.Traits.map(_1.transformToAPITrait),
         generalStats,
         gameStats
     };

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

@@ -1,7 +1,7 @@
 import { Trait } from '../../service';
+import { TraitAttributes, TraitModel } from '../models';
 import { APITrait } from '../../api';
-import { TraitType } from '../models';
-declare function transformToType(trait: Trait): TraitType;
-declare function transformFromType(trait: TraitType): Trait;
-declare function transformToEnum(trait: TraitType): APITrait;
-export { transformToType as transformFromTrait, transformFromType as transformToTrait, transformToEnum as transformToAPITrait };
+declare function transformToAttributes(trait: Trait): TraitAttributes;
+declare function transformToAPIObject(model: TraitModel): APITrait;
+declare function transformToObject(model: TraitModel): Trait;
+export { transformToObject as transformToTrait, transformToAPIObject as transformToAPITrait, transformToAttributes as transformFromTrait };

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

@@ -1,32 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformToAPITrait = exports.transformToTrait = exports.transformFromTrait = void 0;
+exports.transformFromTrait = exports.transformToAPITrait = exports.transformToTrait = void 0;
 const service_1 = require("../../service");
-const api_1 = require("../../api");
-function transformToType(trait) {
-    switch (trait.name) {
-        case 'Marksman':
-            return 'MARKSMAN';
-        case 'Master Mind':
-            return 'MASTER_MIND';
-        case 'Moving Wall':
-            return 'MOVING_WALL';
-        case 'Meteor Serve':
-            return 'METEOR_SERVE';
-        case 'Vigorous':
-            return 'VIGOROUS';
-        case 'Guardian':
-            return 'GUARDIAN';
-        default:
-            throw new Error('UNKNOWN_TRAIT');
-    }
+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
+    };
 }
-exports.transformFromTrait = transformToType;
-function transformFromType(trait) {
-    return service_1.Trait[trait];
+exports.transformFromTrait = transformToAttributes;
+function transformToAPIObject(model) {
+    return { name: model.name };
 }
-exports.transformToTrait = transformFromType;
-function transformToEnum(trait) {
-    return api_1.APITrait[trait];
+exports.transformToAPITrait = transformToAPIObject;
+function transformToObject(model) {
+    return service_1.Trait.getTraits().find(trait => trait.id === model.trait_id);
 }
-exports.transformToAPITrait = transformToEnum;
+exports.transformToTrait = transformToObject;

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

@@ -50,8 +50,8 @@ export declare class MatchSet {
     private readonly scoreThreshold;
     private homeScore;
     private awayScore;
-    constructor({ id, order, isTieBreak, homeLibero, awayLibero, stats, rallies, homeScore, awayScore }: MatchSetOpts);
     private _state;
+    constructor({ id, order, isTieBreak, homeLibero, awayLibero, stats, rallies, homeScore, awayScore }: MatchSetOpts);
     get state(): MatchSetState;
     getHomeScore(): number;
     getAwayScore(): number;

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

@@ -30,8 +30,8 @@ export declare class Rally {
     readonly homePlayerPosition: PlayerPosition[];
     readonly awayPlayerPosition: PlayerPosition[];
     readonly order: number;
-    constructor({ id, order, servingTeam, homePlayerPosition, awayPlayerPosition, events }: RallyOpts);
     private _state;
+    constructor({ id, order, servingTeam, homePlayerPosition, awayPlayerPosition, events }: RallyOpts);
     get state(): RallyState;
     get score(): Score | undefined;
     isOver(): boolean;

package/dist/cjs/src/service/player/trait.d.ts

@@ -1,4 +1,3 @@
-import { Role } from './role';
 import { GeneralStat } from './stats';
 import { PerformanceStats } from './performance-stats';
 export declare class Trait {
@@ -8,8 +7,8 @@ export declare class Trait {
     static readonly METEOR_SERVE: Trait;
     static readonly VIGOROUS: Trait;
     static readonly GUARDIAN: Trait;
+    readonly id: string;
     readonly name: string;
-    readonly roles: Role[];
     readonly modifier: number;
     readonly chance: number;
     readonly statThreshold: number;
@@ -17,5 +16,5 @@ export declare class Trait {
     readonly weight: number;
     private constructor();
     static getTraits(): Trait[];
-    static assignTraits(roles: Role[], performanceStats: PerformanceStats): Trait[];
+    static assignTraits(performanceStats: PerformanceStats): Trait[];
 }

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

@@ -1,12 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Trait = void 0;
-const role_1 = require("./role");
 const stats_1 = require("./stats");
 class Trait {
-    constructor({ name, roles, modifier, chance, statThreshold, stat, weight }) {
+    constructor({ id, name, modifier, chance, statThreshold, stat, weight }) {
+        this.id = id;
         this.name = name;
-        this.roles = roles;
         this.modifier = modifier;
         this.chance = chance;
         this.statThreshold = statThreshold;
@@ -16,10 +15,9 @@ class Trait {
     static getTraits() {
         return [Trait.GUARDIAN, Trait.MARKSMAN, Trait.METEOR_SERVE, Trait.VIGOROUS, Trait.MOVING_WALL, Trait.MASTER_MIND];
     }
-    static assignTraits(roles, performanceStats) {
+    static assignTraits(performanceStats) {
         const qualifiedTraits = this.getTraits().filter(trait => {
-            return (trait.roles.length < 1 || trait.roles.some(role => roles.includes(role))) &&
-                stats_1.GeneralStat.calculateScore(performanceStats, trait.stat) >= trait.statThreshold;
+            return stats_1.GeneralStat.calculateScore(performanceStats, trait.stat) >= trait.statThreshold;
         });
         const random = Math.random();
         let traitCount;
@@ -44,8 +42,8 @@ exports.Trait = Trait;
 // A Setter gets a bonus to their score and the receiving attacker gets a bonus as well.
 // Stacks with attacker bonus
 Trait.MASTER_MIND = new Trait({
+    id: '0117a315-a743-43e3-9ec2-ad5cf700ef08',
     name: 'Master Mind',
-    roles: [role_1.Role.SETTER],
     modifier: 1.25,
     chance: 0.2,
     statThreshold: 80,
@@ -54,8 +52,8 @@ Trait.MASTER_MIND = new Trait({
 });
 // Will always participate in blocking regardless of chance and adds
 Trait.MOVING_WALL = new Trait({
+    id: '304c53f6-5e7a-44d3-9625-f10d8109421a',
     name: 'Moving Wall',
-    roles: [role_1.Role.MIDDLE_BLOCKER, role_1.Role.DEFENSIVE_SPECIALIST],
     modifier: 1.1,
     chance: 1,
     statThreshold: 75,
@@ -64,8 +62,8 @@ Trait.MOVING_WALL = new Trait({
 });
 // On attack, will always pick the worst receiver and adds a 10% to score
 Trait.MARKSMAN = new Trait({
+    id: 'ace3458e-69ab-487c-a9c0-d656f705d8dd',
     name: 'Marksman',
-    roles: [role_1.Role.OUTSIDE_HITTER, role_1.Role.OPPOSITE_HITTER, role_1.Role.SETTER],
     modifier: 1.1,
     chance: 0.3,
     statThreshold: 75,
@@ -74,8 +72,8 @@ Trait.MARKSMAN = new Trait({
 });
 // Increases the score of the serve by 25% when serve type is Jumping.
 Trait.METEOR_SERVE = new Trait({
+    id: 'c929a79d-5866-40d6-bbd6-b0b67a929c4c',
     name: 'Meteor Serve',
-    roles: [],
     modifier: 1.25,
     chance: 0.1,
     statThreshold: 75,
@@ -84,8 +82,8 @@ Trait.METEOR_SERVE = new Trait({
 });
 // Has a 50% chance of taking an action without decreasing energy.
 Trait.VIGOROUS = new Trait({
+    id: 'f9599b87-b3b2-49ce-8224-470f6fe6ed64',
     name: 'Vigorous',
-    roles: [],
     modifier: 1,
     statThreshold: 60,
     chance: 0.5,
@@ -94,8 +92,8 @@ Trait.VIGOROUS = new Trait({
 });
 // Takes place of the receiver and increases reception score by 25%, guaranteeing success. Can only trigger in back-row.
 Trait.GUARDIAN = new Trait({
+    id: 'c3291953-9256-4559-b5a9-955ccb8f9a6f',
     name: 'Guardian',
-    roles: [role_1.Role.DEFENSIVE_SPECIALIST, role_1.Role.LIBERO],
     chance: 0.25,
     statThreshold: 75,
     modifier: 1.25,

package/dist/cjs/src/service/team/team.d.ts

@@ -20,8 +20,8 @@ export declare class Team {
     readonly coach?: Coach;
     readonly league?: League;
     readonly country?: Country;
-    constructor({ id, rating, name, shortName, country, roster, coach, league }: TeamOpts);
     private _rating;
+    constructor({ id, rating, name, shortName, country, roster, coach, league }: TeamOpts);
     get rating(): number;
     set rating(value: number);
     isPlayerInRoster(player: Player): boolean;

package/dist/esm/src/api/player.d.ts

@@ -1,12 +1,7 @@
 import { Country, Name, Role, Stat } from '../service';
 import { APISetStatistics } from './';
-export declare enum APITrait {
-    MASTER_MIND = "Master Mind",
-    MOVING_WALL = "Moving Wall",
-    MARKSMAN = "Marksman",
-    METEOR_SERVE = "Meteor Serve",
-    VIGOROUS = "Vigorous",
-    GUARDIAN = "Guardian"
+export interface APITrait {
+    readonly name: string;
 }
 export interface APIPlayer {
     readonly id: string;

package/dist/esm/src/api/player.js

@@ -1,9 +1 @@
-export var APITrait;
-(function (APITrait) {
-    APITrait["MASTER_MIND"] = "Master Mind";
-    APITrait["MOVING_WALL"] = "Moving Wall";
-    APITrait["MARKSMAN"] = "Marksman";
-    APITrait["METEOR_SERVE"] = "Meteor Serve";
-    APITrait["VIGOROUS"] = "Vigorous";
-    APITrait["GUARDIAN"] = "Guardian";
-})(APITrait || (APITrait = {}));
+export {};

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

@@ -1,4 +1,4 @@
-import { BlockModel, CoachModel, CountryModel, DraftModel, DraftPickModel, EventModel, IterationModel, LeagueModel, LiberoReplacementModel, MatchModel, MatchRatingModel, MatchSetModel, MatchSetStatsModel, PerformanceStatsModel, PlayerModel, PlayerTeamModel, RallyModel, RallyPositionModel, ReceptionModel, ScoreModel, SeasonMatchModel, SeasonModel, SeasonTeamsModel, ServeModel, SetModel, SpikeModel, SubstitutionModel, TeamModel, TournamentMatchModel, TournamentModel, TournamentTeamsModel, UserModel } from './models';
+import { BlockModel, CoachModel, CountryModel, DraftModel, DraftPickModel, EventModel, EventTraitModel, IterationModel, LeagueModel, LiberoReplacementModel, MatchModel, MatchRatingModel, MatchSetModel, MatchSetStatsModel, PerformanceStatsModel, PlayerModel, PlayerTeamModel, PlayerTraitModel, RallyModel, RallyPositionModel, ReceptionModel, ScoreModel, SeasonMatchModel, SeasonModel, SeasonTeamsModel, ServeModel, SetModel, SpikeModel, SubstitutionModel, TeamModel, TournamentMatchModel, TournamentModel, TournamentTeamsModel, TraitModel, UserModel } from './models';
 export function initModels(sequelize) {
     const Block = BlockModel.initModel(sequelize);
     const Coach = CoachModel.initModel(sequelize);
@@ -6,6 +6,7 @@ export function initModels(sequelize) {
     const Draft = DraftModel.initModel(sequelize);
     const DraftPick = DraftPickModel.initModel(sequelize);
     const Event = EventModel.initModel(sequelize);
+    const EventTrait = EventTraitModel.initModel(sequelize);
     const Iteration = IterationModel.initModel(sequelize);
     const League = LeagueModel.initModel(sequelize);
     const LiberoReplacement = LiberoReplacementModel.initModel(sequelize);
@@ -16,6 +17,7 @@ export function initModels(sequelize) {
     const PerformanceStats = PerformanceStatsModel.initModel(sequelize);
     const Player = PlayerModel.initModel(sequelize);
     const PlayerTeam = PlayerTeamModel.initModel(sequelize);
+    const PlayerTrait = PlayerTraitModel.initModel(sequelize);
     const Rally = RallyModel.initModel(sequelize);
     const RallyPosition = RallyPositionModel.initModel(sequelize);
     const Reception = ReceptionModel.initModel(sequelize);
@@ -31,6 +33,7 @@ export function initModels(sequelize) {
     const Tournament = TournamentModel.initModel(sequelize);
     const TournamentMatch = TournamentMatchModel.initModel(sequelize);
     const TournamentTeams = TournamentTeamsModel.initModel(sequelize);
+    const Trait = TraitModel.initModel(sequelize);
     const User = UserModel.initModel(sequelize);
     Draft.hasMany(DraftPick, { as: 'DraftPicks', foreignKey: 'draft_id' });
     DraftPick.belongsTo(Draft, { as: 'draft', foreignKey: 'draft_id' });
@@ -41,6 +44,12 @@ 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'
+    });
     Coach.belongsTo(Country, { as: 'country', foreignKey: 'country_id' });
     Coach.hasMany(Team, { as: 'Teams', foreignKey: 'coach_id' });
     Country.hasMany(Coach, { as: 'Coaches', foreignKey: 'country_id' });
@@ -49,6 +58,13 @@ 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' });
     Iteration.hasMany(Season, { as: 'Seasons', foreignKey: 'iteration' });
     Iteration.hasOne(Tournament, { as: 'Tournament', foreignKey: 'iteration' });
     League.belongsTo(Country, { as: 'country', foreignKey: 'country_id' });
@@ -119,8 +135,15 @@ export function initModels(sequelize) {
         foreignKey: 'player_id',
         otherKey: 'rally_id'
     });
+    Player.belongsToMany(Trait, {
+        as: 'Traits',
+        through: PlayerTrait,
+        foreignKey: 'player_id',
+        otherKey: 'trait_id'
+    });
     PlayerTeam.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
     PlayerTeam.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
+    PlayerTrait.belongsTo(Trait, { as: 'trait', foreignKey: 'trait_id' });
     Rally.belongsTo(MatchSet, { as: 'match_set', foreignKey: 'match_set_id' });
     Rally.belongsTo(Team, { as: 'servingTeam', foreignKey: 'serving_team' });
     Rally.hasMany(Block, { as: 'Blocks', foreignKey: 'rally_id' });
@@ -143,6 +166,12 @@ 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'
+    });
     Score.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
     Score.belongsTo(Rally, { as: 'rally', foreignKey: 'rally_id' });
     Score.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
@@ -163,10 +192,28 @@ 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'
+    });
     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'
+    });
     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'
+    });
     Substitution.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
     Substitution.belongsTo(Player, { as: 'playerOut', foreignKey: 'player_out' });
     Substitution.belongsTo(Rally, { as: 'rally', foreignKey: 'rally_id' });
@@ -216,6 +263,20 @@ 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,
+        foreignKey: 'trait_id',
+        otherKey: 'player_id'
+    });
+    Trait.hasMany(PlayerTrait, { as: 'PlayerTraits', foreignKey: 'trait_id' });
+    Trait.hasMany(EventTrait, { as: 'EventTraits', foreignKey: 'trait_id' });
     return {
         Block,
         Coach,

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

@@ -1,6 +1,6 @@
 import * as Sequelize from 'sequelize';
 import { Model, Optional } from 'sequelize';
-import { CourtTarget, EventType, PlayerId, PlayerModel, RallyId, RallyModel, TraitType } from '.';
+import { CourtTarget, EventType, PlayerId, PlayerModel, RallyId, RallyModel, TraitId, TraitModel } from '.';
 export interface BlockAttributes {
     event_id: string;
     rally_id: string;
@@ -36,7 +36,6 @@ export declare class BlockModel extends Model<BlockAttributes, BlockCreationAttr
     blocker_3?: string;
     modifier: number;
     score: number;
-    active_traits: TraitType[];
     player: PlayerModel;
     getPlayer: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
     setPlayer: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;
@@ -57,5 +56,16 @@ export declare class BlockModel extends Model<BlockAttributes, BlockCreationAttr
     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 BlockModel;
 }

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

@@ -0,0 +1,23 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import type { EventId, EventModel, TraitId, TraitModel } from '.';
+export interface EventTraitAttributes {
+    event_id: string;
+    trait_id: string;
+}
+export type EventTraitPk = 'event_id' | 'trait_id';
+export type EventTraitId = EventTraitModel[EventTraitPk];
+export type EventTraitCreationAttributes = EventTraitAttributes;
+export declare class EventTraitModel extends Model<EventTraitAttributes, EventTraitCreationAttributes> implements EventTraitAttributes {
+    event_id: string;
+    trait_id: string;
+    event: EventModel;
+    getEvent: Sequelize.BelongsToGetAssociationMixin<EventModel>;
+    setEvent: Sequelize.BelongsToSetAssociationMixin<EventModel, EventId>;
+    createEvent: Sequelize.BelongsToCreateAssociationMixin<EventModel>;
+    trait: TraitModel;
+    getTrait: Sequelize.BelongsToGetAssociationMixin<TraitModel>;
+    setTrait: Sequelize.BelongsToSetAssociationMixin<TraitModel, TraitId>;
+    createTrait: Sequelize.BelongsToCreateAssociationMixin<TraitModel>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof EventTraitModel;
+}