volleyballsimtypes 0.0.83 → 0.0.85

package/dist/cjs/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/cjs/src/api/player.js

@@ -1,12 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.APITrait = void 0;
-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 = exports.APITrait || (exports.APITrait = {}));

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

@@ -9,6 +9,7 @@ function initModels(sequelize) {
     const Draft = models_1.DraftModel.initModel(sequelize);
     const DraftPick = models_1.DraftPickModel.initModel(sequelize);
     const Event = models_1.EventModel.initModel(sequelize);
+    const EventTrait = models_1.EventTraitModel.initModel(sequelize);
     const Iteration = models_1.IterationModel.initModel(sequelize);
     const League = models_1.LeagueModel.initModel(sequelize);
     const LiberoReplacement = models_1.LiberoReplacementModel.initModel(sequelize);
@@ -19,6 +20,7 @@ function initModels(sequelize) {
     const PerformanceStats = models_1.PerformanceStatsModel.initModel(sequelize);
     const Player = models_1.PlayerModel.initModel(sequelize);
     const PlayerTeam = models_1.PlayerTeamModel.initModel(sequelize);
+    const PlayerTrait = models_1.PlayerTraitModel.initModel(sequelize);
     const Rally = models_1.RallyModel.initModel(sequelize);
     const RallyPosition = models_1.RallyPositionModel.initModel(sequelize);
     const Reception = models_1.ReceptionModel.initModel(sequelize);
@@ -34,6 +36,7 @@ function initModels(sequelize) {
     const Tournament = models_1.TournamentModel.initModel(sequelize);
     const TournamentMatch = models_1.TournamentMatchModel.initModel(sequelize);
     const TournamentTeams = models_1.TournamentTeamsModel.initModel(sequelize);
+    const Trait = models_1.TraitModel.initModel(sequelize);
     const User = models_1.UserModel.initModel(sequelize);
     Draft.hasMany(DraftPick, { as: 'DraftPicks', foreignKey: 'draft_id' });
     DraftPick.belongsTo(Draft, { as: 'draft', foreignKey: 'draft_id' });
@@ -44,6 +47,13 @@ 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' });
     Coach.belongsTo(Country, { as: 'country', foreignKey: 'country_id' });
     Coach.hasMany(Team, { as: 'Teams', foreignKey: 'coach_id' });
     Country.hasMany(Coach, { as: 'Coaches', foreignKey: 'country_id' });
@@ -52,6 +62,13 @@ 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' });
@@ -122,8 +139,15 @@ 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' });
@@ -146,6 +170,13 @@ 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' });
     Score.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
     Score.belongsTo(Rally, { as: 'rally', foreignKey: 'rally_id' });
     Score.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
@@ -166,10 +197,31 @@ 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' });
     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' });
     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' });
     Substitution.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
     Substitution.belongsTo(Player, { as: 'playerOut', foreignKey: 'player_out' });
     Substitution.belongsTo(Rally, { as: 'rally', foreignKey: 'rally_id' });
@@ -219,6 +271,20 @@ 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/cjs/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, EventTraitAttributes, EventTraitId, EventTraitModel, EventType, PlayerId, PlayerModel, RallyId, RallyModel, TraitId, TraitModel } from '.';
 export interface BlockAttributes {
     event_id: string;
     rally_id: string;
@@ -15,6 +15,7 @@ export interface BlockAttributes {
     blocker_3?: string;
     modifier: number;
     score: number;
+    EventTraits?: EventTraitAttributes[];
 }
 export type BlockType = 'NO_BLOCKER' | 'SINGLE' | 'DOUBLE' | 'TRIPLE';
 export type BlockFailure = 'NO_FAILURE' | 'FAULT' | 'MISS' | 'OUT_OF_BOUNDS' | 'WIPE' | 'TOOL';
@@ -36,7 +37,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 +57,27 @@ 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;
+    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;
     static initModel(sequelize: Sequelize.Sequelize): typeof BlockModel;
 }

package/dist/cjs/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;
+}

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

@@ -0,0 +1,42 @@
+"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({
+            event_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'Event',
+                    key: 'event_id'
+                }
+            },
+            trait_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                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;

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 } from '.';
+import { PlayerId, PlayerModel, RallyId, RallyModel, TraitId, TraitModel } from '.';
 export interface EventAttributes {
     event_id: string;
     rally_id: string;
@@ -27,5 +27,16 @@ 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/index.d.ts

@@ -4,6 +4,7 @@ export * from './country';
 export * from './draft';
 export * from './draft-pick';
 export * from './event';
+export * from './event-trait';
 export * from './iteration';
 export * from './league';
 export * from './libero-replacement';
@@ -14,6 +15,7 @@ export * from './match-set-stats';
 export * from './performance-stats';
 export * from './player';
 export * from './player-team';
+export * from './player-trait';
 export * from './rally';
 export * from './rally-position';
 export * from './reception';
@@ -30,3 +32,4 @@ export * from './tournament';
 export * from './tournament-match';
 export * from './tournament-teams';
 export * from './user';
+export * from './trait';

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

@@ -20,6 +20,7 @@ __exportStar(require("./country"), exports);
 __exportStar(require("./draft"), exports);
 __exportStar(require("./draft-pick"), exports);
 __exportStar(require("./event"), exports);
+__exportStar(require("./event-trait"), exports);
 __exportStar(require("./iteration"), exports);
 __exportStar(require("./league"), exports);
 __exportStar(require("./libero-replacement"), exports);
@@ -30,6 +31,7 @@ __exportStar(require("./match-set-stats"), exports);
 __exportStar(require("./performance-stats"), exports);
 __exportStar(require("./player"), exports);
 __exportStar(require("./player-team"), exports);
+__exportStar(require("./player-trait"), exports);
 __exportStar(require("./rally"), exports);
 __exportStar(require("./rally-position"), exports);
 __exportStar(require("./reception"), exports);
@@ -46,3 +48,4 @@ __exportStar(require("./tournament"), exports);
 __exportStar(require("./tournament-match"), exports);
 __exportStar(require("./tournament-teams"), exports);
 __exportStar(require("./user"), exports);
+__exportStar(require("./trait"), exports);

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

@@ -19,6 +19,7 @@ export declare class MatchModel extends Model<MatchAttributes, MatchCreationAttr
     away_team: string;
     scheduled_date: Date;
     is_simulated: boolean;
+    MatchSets: MatchSetModel[];
     MatchRatings: MatchRatingModel[];
     getMatchRatings: Sequelize.HasManyGetAssociationsMixin<MatchRatingModel>;
     setMatchRatings: Sequelize.HasManySetAssociationsMixin<MatchRatingModel, MatchRatingId>;
@@ -30,7 +31,6 @@ export declare class MatchModel extends Model<MatchAttributes, MatchCreationAttr
     hasMatchRating: Sequelize.HasManyHasAssociationMixin<MatchRatingModel, MatchRatingId>;
     hasMatchRatings: Sequelize.HasManyHasAssociationsMixin<MatchRatingModel, MatchRatingId>;
     countMatchRatings: Sequelize.HasManyCountAssociationsMixin;
-    MatchSets: MatchSetModel[];
     getMatchSets: Sequelize.HasManyGetAssociationsMixin<MatchSetModel>;
     setMatchSets: Sequelize.HasManySetAssociationsMixin<MatchSetModel, MatchSetId>;
     addMatchSet: Sequelize.HasManyAddAssociationMixin<MatchSetModel, MatchSetId>;

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

@@ -0,0 +1,23 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import type { PlayerId, PlayerModel, TraitId, TraitModel } from '.';
+export interface PlayerTraitAttributes {
+    player_id: string;
+    trait_id: string;
+}
+export type PlayerTraitPk = 'player_id' | 'trait_id';
+export type PlayerTraitId = PlayerTraitModel[PlayerTraitPk];
+export type PlayerTraitCreationAttributes = PlayerTraitAttributes;
+export declare class PlayerTraitModel extends Model<PlayerTraitAttributes, PlayerTraitCreationAttributes> implements PlayerTraitAttributes {
+    player_id: string;
+    trait_id: string;
+    player: PlayerModel;
+    getPlayer: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
+    setPlayer: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;
+    createPlayer: Sequelize.BelongsToCreateAssociationMixin<PlayerModel>;
+    trait: TraitModel;
+    getTrait: Sequelize.BelongsToGetAssociationMixin<TraitModel>;
+    setTrait: Sequelize.BelongsToSetAssociationMixin<TraitModel, TraitId>;
+    createTrait: Sequelize.BelongsToCreateAssociationMixin<TraitModel>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof PlayerTraitModel;
+}

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlayerTraitModel = void 0;
+const sequelize_1 = require("sequelize");
+class PlayerTraitModel extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return PlayerTraitModel.init({
+            player_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'Player',
+                    key: 'player_id'
+                }
+            },
+            trait_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'Trait',
+                    key: 'trait_id'
+                }
+            }
+        }, {
+            sequelize,
+            tableName: 'PlayerTrait',
+            schema: 'public',
+            timestamps: false,
+            indexes: [{
+                    name: 'playertrait_pk',
+                    unique: true,
+                    fields: [
+                        { name: 'trait_id' },
+                        { name: 'player_id' },
+                    ]
+                }]
+        });
+    }
+}
+exports.PlayerTraitModel = PlayerTraitModel;

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

@@ -1,19 +1,16 @@
 import * as Sequelize from 'sequelize';
 import { Model } from 'sequelize';
-import type { BlockId, CountryId, DraftPickId, EventId, LiberoReplacementId, MatchSetId, MatchSetStatsId, PerformanceStatsId, PlayerTeamId, RallyId, RallyPositionId, ReceptionId, ScoreId, ServeId, SetId, SpikeId, SubstitutionId } from '.';
-import { BlockModel, CountryModel, DraftPickModel, EventModel, LiberoReplacementModel, MatchSetModel, MatchSetStatsAttributes, MatchSetStatsModel, PerformanceStatsAttributes, PerformanceStatsModel, PlayerTeamModel, RallyModel, RallyPositionModel, ReceptionModel, ScoreModel, ServeModel, SetModel, SpikeModel, SubstitutionModel } from '.';
+import { BlockId, BlockModel, CountryId, CountryModel, DraftPickId, DraftPickModel, EventId, EventModel, LiberoReplacementId, LiberoReplacementModel, MatchSetId, MatchSetModel, MatchSetStatsAttributes, MatchSetStatsId, MatchSetStatsModel, PerformanceStatsAttributes, PerformanceStatsId, PerformanceStatsModel, PlayerTeamId, PlayerTeamModel, RallyId, RallyModel, RallyPositionId, RallyPositionModel, ReceptionId, ReceptionModel, ScoreId, ScoreModel, ServeId, ServeModel, SetId, SetModel, SpikeId, SpikeModel, SubstitutionId, SubstitutionModel, TraitId, TraitModel } from '.';
 export interface PlayerAttributes {
     player_id: string;
     roles: RoleType[];
     first_name: string;
     last_name: string;
     country_id: string;
-    traits: TraitType[];
     PerformanceStat?: PerformanceStatsAttributes;
     MatchSetStats?: MatchSetStatsAttributes[];
 }
 export type RoleType = 'SETTER' | 'LIBERO' | 'OUTSIDE_HITTER' | 'OPPOSITE_HITTER' | 'MIDDLE_BLOCKER' | 'DEFENSIVE_SPECIALIST';
-export type TraitType = 'MARKSMAN' | 'MOVING_WALL' | 'MASTER_MIND' | 'METEOR_SERVE' | 'VIGOROUS' | 'GUARDIAN';
 export type PlayerPk = 'player_id';
 export type PlayerId = PlayerModel[PlayerPk];
 export type PlayerCreationAttributes = PlayerAttributes;
@@ -23,7 +20,8 @@ export declare class PlayerModel extends Model<PlayerAttributes, PlayerCreationA
     first_name: string;
     last_name: string;
     country_id: string;
-    traits: TraitType[];
+    PerformanceStat: PerformanceStatsModel;
+    MatchSetStats: MatchSetStatsModel[];
     country: CountryModel;
     getCountry: Sequelize.BelongsToGetAssociationMixin<CountryModel>;
     setCountry: Sequelize.BelongsToSetAssociationMixin<CountryModel, CountryId>;
@@ -142,7 +140,6 @@ export declare class PlayerModel extends Model<PlayerAttributes, PlayerCreationA
     hasMatchSet: Sequelize.BelongsToManyHasAssociationMixin<MatchSetModel, MatchSetId>;
     hasMatchSets: Sequelize.BelongsToManyHasAssociationsMixin<MatchSetModel, MatchSetId>;
     countMatchSets: Sequelize.BelongsToManyCountAssociationsMixin;
-    MatchSetStats: MatchSetStatsModel[];
     getMatchSetStats: Sequelize.HasManyGetAssociationsMixin<MatchSetStatsModel>;
     setMatchSetStats: Sequelize.HasManySetAssociationsMixin<MatchSetStatsModel, MatchSetStatsId>;
     addMatchSetStat: Sequelize.HasManyAddAssociationMixin<MatchSetStatsModel, MatchSetStatsId>;
@@ -153,7 +150,6 @@ export declare class PlayerModel extends Model<PlayerAttributes, PlayerCreationA
     hasMatchSetStat: Sequelize.HasManyHasAssociationMixin<MatchSetStatsModel, MatchSetStatsId>;
     hasMatchSetStats: Sequelize.HasManyHasAssociationsMixin<MatchSetStatsModel, MatchSetStatsId>;
     countMatchSetStats: Sequelize.HasManyCountAssociationsMixin;
-    PerformanceStat: PerformanceStatsModel;
     getPerformanceStat: Sequelize.HasOneGetAssociationMixin<PerformanceStatsModel>;
     setPerformanceStat: Sequelize.HasOneSetAssociationMixin<PerformanceStatsModel, PerformanceStatsId>;
     createPerformanceStat: Sequelize.HasOneCreateAssociationMixin<PerformanceStatsModel>;
@@ -260,5 +256,16 @@ export declare class PlayerModel extends Model<PlayerAttributes, PlayerCreationA
     hasInSubstitution: Sequelize.HasManyHasAssociationMixin<SubstitutionModel, SubstitutionId>;
     hasInSubstitutions: Sequelize.HasManyHasAssociationsMixin<SubstitutionModel, SubstitutionId>;
     countInSubstitutions: Sequelize.HasManyCountAssociationsMixin;
+    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 PlayerModel;
 }

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

@@ -29,10 +29,6 @@ class PlayerModel extends sequelize_1.Model {
                     model: 'Country',
                     key: 'country_id'
                 }
-            },
-            traits: {
-                type: sequelize_1.DataTypes.ARRAY(sequelize_1.DataTypes.ENUM('MARKSMAN', 'MOVING_WALL', 'MASTER_MIND', 'METEOR_SERVE', 'VIGOROUS', 'GUARDIAN')),
-                allowNull: false
             }
         }, {
             sequelize,

package/dist/cjs/src/data/models/reception.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, EventTraitAttributes, EventTraitId, EventTraitModel, EventType, PlayerId, PlayerModel, RallyId, RallyModel, TraitId, TraitModel } from '.';
 export interface ReceptionAttributes {
     event_id: string;
     rally_id: string;
@@ -12,6 +12,7 @@ export interface ReceptionAttributes {
     player_id: string;
     modifier: number;
     score: number;
+    EventTraits?: EventTraitAttributes[];
 }
 export type ReceptionFailure = 'NO_FAILURE' | 'FAULT' | 'MISS' | 'OUT_OF_BOUNDS' | 'BAD_PASS';
 export type ReceptionType = 'DIG' | 'OVERHAND' | 'ONE_HAND' | 'OTHER_BODY_PART';
@@ -29,7 +30,6 @@ export declare class ReceptionModel extends Model<ReceptionAttributes, Reception
     player_id: string;
     modifier: number;
     score: number;
-    active_traits: TraitType[];
     player: PlayerModel;
     getPlayer: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
     setPlayer: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;
@@ -38,5 +38,27 @@ export declare class ReceptionModel extends Model<ReceptionAttributes, Reception
     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;
+    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;
     static initModel(sequelize: Sequelize.Sequelize): typeof ReceptionModel;
 }

package/dist/cjs/src/data/models/season-match.d.ts

@@ -13,11 +13,11 @@ export type SeasonMatchCreationAttributes = SeasonMatchAttributes;
 export declare class SeasonMatchModel extends Model<SeasonMatchAttributes, SeasonMatchCreationAttributes> implements SeasonMatchAttributes {
     season_id: string;
     match_id: string;
+    match: MatchModel;
     season: SeasonModel;
     getSeason: Sequelize.BelongsToGetAssociationMixin<SeasonModel>;
     setSeason: Sequelize.BelongsToSetAssociationMixin<SeasonModel, SeasonId>;
     createSeason: Sequelize.BelongsToCreateAssociationMixin<SeasonModel>;
-    match: MatchModel;
     getMatch: Sequelize.BelongsToGetAssociationMixin<MatchModel>;
     setMatch: Sequelize.BelongsToSetAssociationMixin<MatchModel, MatchId>;
     createMatch: Sequelize.BelongsToCreateAssociationMixin<MatchModel>;

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

@@ -18,11 +18,13 @@ export declare class SeasonModel extends Model<SeasonAttributes, SeasonCreationA
     season_id: string;
     iteration: number;
     league_id: string;
+    seasonTeams: TeamModel[];
+    SeasonMatches: SeasonMatchModel[];
+    league: LeagueModel;
     Iteration: IterationModel;
     getIteration: Sequelize.BelongsToGetAssociationMixin<IterationModel>;
     setIteration: Sequelize.BelongsToSetAssociationMixin<IterationModel, IterationId>;
     createIteration: Sequelize.BelongsToCreateAssociationMixin<IterationModel>;
-    league: LeagueModel;
     getLeague: Sequelize.BelongsToGetAssociationMixin<LeagueModel>;
     setLeague: Sequelize.BelongsToSetAssociationMixin<LeagueModel, LeagueId>;
     createLeague: Sequelize.BelongsToCreateAssociationMixin<LeagueModel>;
@@ -37,7 +39,6 @@ export declare class SeasonModel extends Model<SeasonAttributes, SeasonCreationA
     hasSeasonTeam: Sequelize.HasManyHasAssociationMixin<SeasonTeamsModel, SeasonTeamsId>;
     hasSeasonTeams: Sequelize.HasManyHasAssociationsMixin<SeasonTeamsModel, SeasonTeamsId>;
     countSeasonTeams: Sequelize.HasManyCountAssociationsMixin;
-    seasonTeams: TeamModel[];
     getseasonTeams: Sequelize.BelongsToManyGetAssociationsMixin<TeamModel>;
     setseasonTeams: Sequelize.BelongsToManySetAssociationsMixin<TeamModel, TeamId>;
     addTeam_id_Team: Sequelize.BelongsToManyAddAssociationMixin<TeamModel, TeamId>;
@@ -48,7 +49,6 @@ export declare class SeasonModel extends Model<SeasonAttributes, SeasonCreationA
     hasTeam_id_Team: Sequelize.BelongsToManyHasAssociationMixin<TeamModel, TeamId>;
     hasseasonTeams: Sequelize.BelongsToManyHasAssociationsMixin<TeamModel, TeamId>;
     countseasonTeams: Sequelize.BelongsToManyCountAssociationsMixin;
-    SeasonMatches: SeasonMatchModel[];
     getSeasonMatches: Sequelize.HasManyGetAssociationsMixin<SeasonMatchModel>;
     setSeasonMatches: Sequelize.HasManySetAssociationsMixin<SeasonMatchModel, SeasonMatchId>;
     addSeasonMatch: Sequelize.HasManyAddAssociationMixin<SeasonMatchModel, SeasonMatchId>;