volleyballsimtypes 0.0.83 → 0.0.85

package/dist/esm/src/data/models/set.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 SetAttributes {
     event_id: string;
     rally_id: string;
@@ -12,6 +12,7 @@ export interface SetAttributes {
     player_id: string;
     modifier: number;
     score: number;
+    EventTraits?: EventTraitAttributes[];
 }
 export type SetFailure = 'NO_FAILURE' | 'FAULT' | 'MISS' | 'OUT_OF_BOUNDS' | 'BAD_PASS';
 export type SetType = 'OVERHAND' | 'UNDERHAND' | 'SPIKE' | 'DUMP';
@@ -29,7 +30,6 @@ export declare class SetModel extends Model<SetAttributes, SetCreationAttributes
     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 SetModel extends Model<SetAttributes, SetCreationAttributes
     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 SetModel;
 }

package/dist/esm/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, EventTraitAttributes, EventTraitId, EventTraitModel, EventType, PlayerId, PlayerModel, RallyId, RallyModel, TraitId, TraitModel } from '.';
 export interface SpikeAttributes {
     event_id: string;
     rally_id: string;
@@ -12,6 +12,7 @@ export interface SpikeAttributes {
     player_id: string;
     modifier: number;
     score: number;
+    EventTraits?: EventTraitAttributes[];
 }
 export type SpikeType = 'CROSS_SHOT' | 'LINE_SHOT' | 'TOOL_SHOT' | 'TIP' | 'DOWN_BALL' | 'OVERHAND';
 export type SpikeFailure = 'NO_FAILURE' | 'FAULT' | 'MISS' | 'OUT_OF_BOUNDS' | 'NET';
@@ -29,7 +30,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 +38,27 @@ 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;
+    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 SpikeModel;
 }

package/dist/esm/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/esm/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/esm/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/esm/src/data/models/trait.js

@@ -0,0 +1,46 @@
+import { DataTypes, Model } from 'sequelize';
+export class TraitModel extends Model {
+    static initModel(sequelize) {
+        return TraitModel.init({
+            trait_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true
+            },
+            name: {
+                type: DataTypes.STRING,
+                allowNull: false
+            },
+            modifier: {
+                type: DataTypes.REAL,
+                allowNull: false
+            },
+            chance: {
+                type: DataTypes.REAL,
+                allowNull: false
+            },
+            threshold: {
+                type: DataTypes.INTEGER,
+                allowNull: false
+            },
+            weight: {
+                type: DataTypes.INTEGER,
+                allowNull: false
+            },
+            general_stat: {
+                type: 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' }]
+                }]
+        });
+    }
+}

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

@@ -1,12 +1,11 @@
 import { GeneralStat, Player } from '../../service';
-import { transformFromPerformanceStats, transformFromRole, transformFromTrait, transformToAPIMatchSetStats, transformToAPITrait, transformToCountry, transformToPerformanceStats, transformToRole, transformToTrait } from '.';
+import { transformFromPerformanceStats, transformFromRole, transformToAPIMatchSetStats, transformToAPITrait, transformToCountry, transformToPerformanceStats, transformToRole, transformToTrait } from '.';
 function transformToAttributes(player) {
     return {
         player_id: player.id,
         country_id: player.country.id,
         first_name: player.name.first,
         last_name: player.name.last,
-        traits: player.traits.map(transformFromTrait),
         roles: player.roles.map(transformFromRole),
         PerformanceStat: transformFromPerformanceStats(player)
     };
@@ -20,7 +19,7 @@ function transformToObject(model) {
         },
         country: transformToCountry(model.country),
         roles: model.roles.map(transformToRole),
-        traits: model.traits.map(transformToTrait),
+        traits: model.Traits.map(transformToTrait),
         stats: transformToPerformanceStats(model.PerformanceStat)
     });
 }
@@ -39,7 +38,7 @@ function transformToAPIObject(model) {
         },
         country: transformToCountry(model.country),
         roles: model.roles.map(transformToRole),
-        traits: model.traits.map(transformToAPITrait),
+        traits: model.Traits.map(transformToAPITrait),
         generalStats,
         gameStats
     };

package/dist/esm/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/esm/src/data/transformers/trait.js

@@ -1,27 +1,19 @@
 import { Trait } from '../../service';
-import { APITrait } from '../../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
+    };
 }
-function transformFromType(trait) {
-    return Trait[trait];
+function transformToAPIObject(model) {
+    return { name: model.name };
 }
-function transformToEnum(trait) {
-    return APITrait[trait];
+function transformToObject(model) {
+    return Trait.getTraits().find(trait => trait.id === model.trait_id);
 }
-export { transformToType as transformFromTrait, transformFromType as transformToTrait, transformToEnum as transformToAPITrait };
+export { transformToObject as transformToTrait, transformToAPIObject as transformToAPITrait, transformToAttributes as transformFromTrait };

package/dist/esm/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/esm/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/esm/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/esm/src/service/player/trait.js

@@ -1,9 +1,8 @@
-import { Role } from './role';
 import { GeneralStat } from './stats';
 export 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;
@@ -13,10 +12,9 @@ export 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))) &&
-                GeneralStat.calculateScore(performanceStats, trait.stat) >= trait.statThreshold;
+            return GeneralStat.calculateScore(performanceStats, trait.stat) >= trait.statThreshold;
         });
         const random = Math.random();
         let traitCount;
@@ -40,8 +38,8 @@ export class 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.SETTER],
     modifier: 1.25,
     chance: 0.2,
     statThreshold: 80,
@@ -50,8 +48,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.MIDDLE_BLOCKER, Role.DEFENSIVE_SPECIALIST],
     modifier: 1.1,
     chance: 1,
     statThreshold: 75,
@@ -60,8 +58,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.OUTSIDE_HITTER, Role.OPPOSITE_HITTER, Role.SETTER],
     modifier: 1.1,
     chance: 0.3,
     statThreshold: 75,
@@ -70,8 +68,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,
@@ -80,8 +78,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,
@@ -90,8 +88,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.DEFENSIVE_SPECIALIST, Role.LIBERO],
     chance: 0.25,
     statThreshold: 75,
     modifier: 1.25,

package/dist/esm/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/package.json

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