volleyballsimtypes 0.0.166 → 0.0.167

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

@@ -17,9 +17,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 './set-position';
 export * from './team';
-export * from './trait';
 export * from './user';

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

@@ -17,9 +17,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 './set-position';
 export * from './team';
-export * from './trait';
 export * from './user';

package/dist/esm/src/data/models/performance-stats.d.ts

@@ -20,6 +20,7 @@ export interface PerformanceStatsAttributes {
     focus: number;
     defense: number;
     stamina: number;
+    saving: number;
 }
 export type PerformanceStatsPk = 'player_id';
 export type PerformanceStatsId = PerformanceStatsModel[PerformanceStatsPk];
@@ -43,6 +44,7 @@ export declare class PerformanceStatsModel extends Model<PerformanceStatsAttribu
     focus: number;
     defense: number;
     stamina: number;
+    saving: number;
     player: PlayerModel;
     getPlayer: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
     setPlayer: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;

package/dist/esm/src/data/models/performance-stats.js

@@ -95,6 +95,11 @@ export class PerformanceStatsModel extends Model {
                 type: DataTypes.INTEGER,
                 allowNull: false,
                 defaultValue: 0
+            },
+            saving: {
+                type: DataTypes.INTEGER,
+                allowNull: false,
+                defaultValue: 0
             }
         }, {
             sequelize,

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

@@ -1,11 +1,12 @@
 import * as Sequelize from 'sequelize';
 import { Model } from 'sequelize';
-import { CountryId, CountryModel, DraftPickId, DraftPickModel, MatchSetId, MatchSetModel, MatchSetStatsAttributes, MatchSetStatsId, MatchSetStatsModel, PerformanceStatsAttributes, PerformanceStatsId, PerformanceStatsModel, PlayerTeamId, PlayerTeamModel, PlayerTraitId, PlayerTraitModel, SetPositionId, SetPositionModel, TeamId, TeamModel, TraitId, TraitModel } from '.';
-import { Rarity } from '../../service';
+import { CountryId, CountryModel, DraftPickId, DraftPickModel, MatchSetId, MatchSetModel, MatchSetStatsAttributes, MatchSetStatsId, MatchSetStatsModel, PerformanceStatsAttributes, PerformanceStatsId, PerformanceStatsModel, PlayerTeamId, PlayerTeamModel, SetPositionId, SetPositionModel, TeamId, TeamModel } from '.';
+import { Rarity, Role, Trait } from '../../service';
 export interface PlayerAttributes {
     player_id: string;
-    roles: RoleType[];
-    rarity: PlayerRarity;
+    roles: Role[];
+    traits: Trait[];
+    rarity: Rarity;
     first_name: string;
     last_name: string;
     country_id: string;
@@ -13,14 +14,13 @@ export interface PlayerAttributes {
     MatchSetStats?: MatchSetStatsAttributes[];
 }
 export type PlayerPk = 'player_id';
-export type RoleType = 'SETTER' | 'LIBERO' | 'OUTSIDE_HITTER' | 'OPPOSITE_HITTER' | 'MIDDLE_BLOCKER';
-export type PlayerRarity = Rarity.COMMON | Rarity.RARE | Rarity.LEGENDARY | Rarity.MYTHIC | Rarity.SPECIAL;
 export type PlayerId = PlayerModel[PlayerPk];
 export type PlayerCreationAttributes = PlayerAttributes;
 export declare class PlayerModel extends Model<PlayerAttributes, PlayerCreationAttributes> implements PlayerAttributes {
     player_id: string;
-    roles: RoleType[];
-    rarity: PlayerRarity;
+    roles: Role[];
+    traits: Trait[];
+    rarity: Rarity;
     first_name: string;
     last_name: string;
     country_id: string;
@@ -80,17 +80,6 @@ export declare class PlayerModel extends Model<PlayerAttributes, PlayerCreationA
     hasPlayerTeam: Sequelize.HasManyHasAssociationMixin<PlayerTeamModel, PlayerTeamId>;
     hasPlayerTeams: Sequelize.HasManyHasAssociationsMixin<PlayerTeamModel, PlayerTeamId>;
     countPlayerTeams: Sequelize.HasManyCountAssociationsMixin;
-    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;
     SetPositions: SetPositionModel[];
     getSetPositions: Sequelize.HasManyGetAssociationsMixin<SetPositionModel>;
     setSetPositions: Sequelize.HasManySetAssociationsMixin<SetPositionModel, SetPositionId>;
@@ -113,16 +102,5 @@ export declare class PlayerModel extends Model<PlayerAttributes, PlayerCreationA
     hasTeam: Sequelize.BelongsToManyHasAssociationMixin<TeamModel, TeamId>;
     hasTeams: Sequelize.BelongsToManyHasAssociationsMixin<TeamModel, TeamId>;
     countTeams: Sequelize.BelongsToManyCountAssociationsMixin;
-    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/esm/src/data/models/player.js

@@ -1,5 +1,5 @@
 import { DataTypes, Model } from 'sequelize';
-import { Rarity } from '../../service';
+import { RarityDataType, RoleDataType, TraitDataType } from '../../service';
 export class PlayerModel extends Model {
     static initModel(sequelize) {
         return PlayerModel.init({
@@ -9,11 +9,15 @@ export class PlayerModel extends Model {
                 primaryKey: true
             },
             roles: {
-                type: DataTypes.ARRAY(DataTypes.ENUM('SETTER', 'LIBERO', 'OUTSIDE_HITTER', 'OPPOSITE_HITTER', 'MIDDLE_BLOCKER')),
+                type: DataTypes.ARRAY(RoleDataType),
+                allowNull: false
+            },
+            traits: {
+                type: DataTypes.ARRAY(TraitDataType),
                 allowNull: false
             },
             rarity: {
-                type: DataTypes.ENUM(...Object.values(Rarity)),
+                type: DataTypes.ENUM(RarityDataType),
                 allowNull: false
             },
             first_name: {

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

@@ -16,10 +16,8 @@ export * from './performance-stats';
 export * from './player';
 export * from './rally';
 export * from './set-position';
-export * from './role';
 export * from './season';
 export * from './season-match';
 export * from './player-team';
 export * from './match-rating';
 export * from './team';
-export * from './trait';

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

@@ -16,10 +16,8 @@ export * from './performance-stats';
 export * from './player';
 export * from './rally';
 export * from './set-position';
-export * from './role';
 export * from './season';
 export * from './season-match';
 export * from './player-team';
 export * from './match-rating';
 export * from './team';
-export * from './trait';

package/dist/esm/src/data/transformers/performance-stats.js

@@ -18,7 +18,8 @@ function transformToAttributes(player) {
         bump: player.stats.bump,
         setting: player.stats.setting,
         spike: player.stats.spike,
-        stamina: player.stats.stamina
+        stamina: player.stats.stamina,
+        saving: player.stats.saving
     };
 }
 function transformToObject(model) {
@@ -39,7 +40,8 @@ function transformToObject(model) {
         commit: model.commit,
         focus: model.focus,
         defense: model.defense,
-        stamina: model.stamina
+        stamina: model.stamina,
+        saving: model.saving
     });
 }
 export { transformToObject as transformToPerformanceStats, transformToAttributes as transformFromPerformanceStats };

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

@@ -1,12 +1,13 @@
 import { Player } from '../../service';
-import { transformFromPerformanceStats, transformFromRole, transformToCountry, transformToPerformanceStats, transformToRole, transformToTrait } from '.';
+import { transformFromPerformanceStats, transformToCountry, transformToPerformanceStats } from '.';
 function transformToAttributes(player) {
     return {
         player_id: player.id,
         country_id: player.country.id,
         first_name: player.name.first,
         last_name: player.name.last,
-        roles: player.roles.map(transformFromRole),
+        roles: player.roles,
+        traits: player.traits,
         PerformanceStat: transformFromPerformanceStats(player),
         rarity: player.rarity
     };
@@ -19,8 +20,8 @@ function transformToObject(model) {
             last: model.last_name
         },
         country: transformToCountry(model.country),
-        roles: model.roles.map(transformToRole),
-        traits: model.Traits.map(transformToTrait),
+        roles: model.roles,
+        traits: model.traits,
         stats: transformToPerformanceStats(model.PerformanceStat),
         rarity: model.rarity
     });

package/dist/esm/src/index.d.ts

@@ -1,3 +1,2 @@
 export * from './service';
 export * from './data';
-export * from './formula';

package/dist/esm/src/index.js

@@ -1,3 +1,2 @@
 export * from './service';
 export * from './data';
-export * from './formula';

package/dist/esm/src/service/coach/formation.js

@@ -1,4 +1,4 @@
-import { Role } from '../player';
+import { RoleEnum } from '../player';
 import { CourtPosition } from '../match';
 export class Formation {
     constructor({ name, initialRotation, base, draftingPriorities, liberoSubPriority }) {
@@ -15,29 +15,29 @@ export class Formation {
 Formation['5-1'] = new Formation({
     name: '5-1',
     initialRotation: {
-        1: [Role.SETTER],
-        2: [Role.OUTSIDE_HITTER],
-        3: [Role.MIDDLE_BLOCKER],
-        4: [Role.OPPOSITE_HITTER],
-        5: [Role.OUTSIDE_HITTER],
-        6: [Role.MIDDLE_BLOCKER]
+        1: [RoleEnum.SETTER],
+        2: [RoleEnum.OUTSIDE_HITTER],
+        3: [RoleEnum.MIDDLE_BLOCKER],
+        4: [RoleEnum.OPPOSITE_HITTER],
+        5: [RoleEnum.OUTSIDE_HITTER],
+        6: [RoleEnum.MIDDLE_BLOCKER]
     },
     base: {
-        1: [Role.OPPOSITE_HITTER, Role.SETTER],
-        2: [Role.OPPOSITE_HITTER],
-        3: [Role.MIDDLE_BLOCKER],
-        4: [Role.OUTSIDE_HITTER],
-        5: [Role.OUTSIDE_HITTER],
-        6: [Role.LIBERO]
+        1: [RoleEnum.OPPOSITE_HITTER, RoleEnum.SETTER],
+        2: [RoleEnum.OPPOSITE_HITTER],
+        3: [RoleEnum.MIDDLE_BLOCKER],
+        4: [RoleEnum.OUTSIDE_HITTER],
+        5: [RoleEnum.OUTSIDE_HITTER],
+        6: [RoleEnum.LIBERO]
     },
     draftingPriorities: [
-        [Role.SETTER, Role.OPPOSITE_HITTER],
-        [Role.OPPOSITE_HITTER],
-        [Role.MIDDLE_BLOCKER],
-        [Role.MIDDLE_BLOCKER],
-        [Role.OUTSIDE_HITTER],
-        [Role.OUTSIDE_HITTER],
-        [Role.LIBERO]
+        [RoleEnum.SETTER, RoleEnum.OPPOSITE_HITTER],
+        [RoleEnum.OPPOSITE_HITTER],
+        [RoleEnum.MIDDLE_BLOCKER],
+        [RoleEnum.MIDDLE_BLOCKER],
+        [RoleEnum.OUTSIDE_HITTER],
+        [RoleEnum.OUTSIDE_HITTER],
+        [RoleEnum.LIBERO]
     ],
     liberoSubPriority: {
         MIDDLE_BLOCKER: 1,
@@ -50,29 +50,29 @@ Formation['5-1'] = new Formation({
 Formation['4-2'] = new Formation({
     name: '4-2',
     initialRotation: {
-        1: [Role.MIDDLE_BLOCKER],
-        2: [Role.SETTER],
-        3: [Role.OUTSIDE_HITTER],
-        4: [Role.MIDDLE_BLOCKER],
-        5: [Role.SETTER],
-        6: [Role.OPPOSITE_HITTER]
+        1: [RoleEnum.MIDDLE_BLOCKER],
+        2: [RoleEnum.SETTER],
+        3: [RoleEnum.OUTSIDE_HITTER],
+        4: [RoleEnum.MIDDLE_BLOCKER],
+        5: [RoleEnum.SETTER],
+        6: [RoleEnum.OPPOSITE_HITTER]
     },
     base: {
-        1: [Role.SETTER],
-        2: [Role.OPPOSITE_HITTER, Role.SETTER],
-        3: [Role.MIDDLE_BLOCKER],
-        4: [Role.OUTSIDE_HITTER],
-        5: [Role.OUTSIDE_HITTER],
-        6: [Role.LIBERO]
+        1: [RoleEnum.SETTER],
+        2: [RoleEnum.OPPOSITE_HITTER, RoleEnum.SETTER],
+        3: [RoleEnum.MIDDLE_BLOCKER],
+        4: [RoleEnum.OUTSIDE_HITTER],
+        5: [RoleEnum.OUTSIDE_HITTER],
+        6: [RoleEnum.LIBERO]
     },
     draftingPriorities: [
-        [Role.SETTER, Role.OPPOSITE_HITTER],
-        [Role.SETTER],
-        [Role.MIDDLE_BLOCKER],
-        [Role.MIDDLE_BLOCKER],
-        [Role.OUTSIDE_HITTER],
-        [Role.OUTSIDE_HITTER],
-        [Role.LIBERO]
+        [RoleEnum.SETTER, RoleEnum.OPPOSITE_HITTER],
+        [RoleEnum.SETTER],
+        [RoleEnum.MIDDLE_BLOCKER],
+        [RoleEnum.MIDDLE_BLOCKER],
+        [RoleEnum.OUTSIDE_HITTER],
+        [RoleEnum.OUTSIDE_HITTER],
+        [RoleEnum.LIBERO]
     ],
     liberoSubPriority: {
         MIDDLE_BLOCKER: 1,
@@ -85,29 +85,29 @@ Formation['4-2'] = new Formation({
 Formation['6-2'] = new Formation({
     name: '6-2',
     initialRotation: {
-        1: [Role.OPPOSITE_HITTER, Role.SETTER],
-        2: [Role.OUTSIDE_HITTER],
-        3: [Role.MIDDLE_BLOCKER],
-        4: [Role.OPPOSITE_HITTER, Role.SETTER],
-        5: [Role.OUTSIDE_HITTER],
-        6: [Role.MIDDLE_BLOCKER]
+        1: [RoleEnum.OPPOSITE_HITTER, RoleEnum.SETTER],
+        2: [RoleEnum.OUTSIDE_HITTER],
+        3: [RoleEnum.MIDDLE_BLOCKER],
+        4: [RoleEnum.OPPOSITE_HITTER, RoleEnum.SETTER],
+        5: [RoleEnum.OUTSIDE_HITTER],
+        6: [RoleEnum.MIDDLE_BLOCKER]
     },
     base: {
-        1: [Role.SETTER],
-        2: [Role.OPPOSITE_HITTER, Role.SETTER],
-        3: [Role.MIDDLE_BLOCKER],
-        4: [Role.OUTSIDE_HITTER],
-        5: [Role.OUTSIDE_HITTER],
-        6: [Role.LIBERO]
+        1: [RoleEnum.SETTER],
+        2: [RoleEnum.OPPOSITE_HITTER, RoleEnum.SETTER],
+        3: [RoleEnum.MIDDLE_BLOCKER],
+        4: [RoleEnum.OUTSIDE_HITTER],
+        5: [RoleEnum.OUTSIDE_HITTER],
+        6: [RoleEnum.LIBERO]
     },
     draftingPriorities: [
-        [Role.SETTER, Role.OPPOSITE_HITTER],
-        [Role.OPPOSITE_HITTER, Role.SETTER],
-        [Role.MIDDLE_BLOCKER],
-        [Role.MIDDLE_BLOCKER],
-        [Role.OUTSIDE_HITTER],
-        [Role.OUTSIDE_HITTER],
-        [Role.LIBERO]
+        [RoleEnum.SETTER, RoleEnum.OPPOSITE_HITTER],
+        [RoleEnum.OPPOSITE_HITTER, RoleEnum.SETTER],
+        [RoleEnum.MIDDLE_BLOCKER],
+        [RoleEnum.MIDDLE_BLOCKER],
+        [RoleEnum.OUTSIDE_HITTER],
+        [RoleEnum.OUTSIDE_HITTER],
+        [RoleEnum.LIBERO]
     ],
     liberoSubPriority: {
         MIDDLE_BLOCKER: 1,

package/dist/esm/src/service/player/index.d.ts

@@ -1,5 +1,6 @@
 export * from './player';
 export * from './performance-stats';
-export * from './role';
 export * from './trait';
 export * from './rarity';
+export * from './role';
+export * from './stats';

package/dist/esm/src/service/player/index.js

@@ -1,5 +1,6 @@
 export * from './player';
 export * from './performance-stats';
-export * from './role';
 export * from './trait';
 export * from './rarity';
+export * from './role';
+export * from './stats';

package/dist/esm/src/service/player/performance-stats.d.ts

@@ -1,4 +1,4 @@
-export declare const performanceStatKeys: readonly ["setting", "serve", "spike", "quick", "power", "awareness", "attack", "backAttack", "reception", "overhand", "bump", "block", "read", "commit", "focus", "defense", "stamina"];
+export declare const performanceStatKeys: readonly ["setting", "serve", "spike", "quick", "power", "awareness", "attack", "backAttack", "reception", "overhand", "bump", "block", "read", "commit", "focus", "defense", "stamina", "saving"];
 export type PerformanceStatsKey = typeof performanceStatKeys[number];
 export type PerformanceStatsParams = Record<PerformanceStatsKey, number>;
 export interface PerformanceStats extends PerformanceStatsParams {

package/dist/esm/src/service/player/performance-stats.js

@@ -1,5 +1,5 @@
 export const performanceStatKeys = ['setting', 'serve', 'spike', 'quick', 'power', 'awareness', 'attack', 'backAttack',
-    'reception', 'overhand', 'bump', 'block', 'read', 'commit', 'focus', 'defense', 'stamina'];
+    'reception', 'overhand', 'bump', 'block', 'read', 'commit', 'focus', 'defense', 'stamina', 'saving'];
 export class PerformanceStats {
     constructor(opts) {
         Object.assign(this, opts);

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

@@ -1,14 +1,14 @@
 import { PerformanceStats } from './performance-stats';
-import { Role } from './role';
 import { Trait } from './trait';
 import { Country } from '../country';
-import * as GeneralStat from '../../formula/stats';
 import { Rarity } from './rarity';
+import { Stats } from './stats';
+import { Role } from './role';
 export declare class Stat {
-    readonly name: GeneralStat.Stats;
+    readonly name: Stats;
     readonly value: number;
     constructor({ name, value }: {
-        name: GeneralStat.Stats;
+        name: Stats;
         value: number;
     });
     toString(): string;
@@ -43,7 +43,6 @@ export declare class Player {
     constructor({ id, name, country, stats, roles, traits, rarity }: PlayerParams);
     static sortPlayers(roles: Role[]): (p1: Player, p2: Player) => number;
     static compareStats(p1: Player, p2: Player): number;
-    canPlayLibero(): boolean;
     toString(): string;
 }
 export {};

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

@@ -1,6 +1,6 @@
-import { Role } from './role';
 import { validateUUID } from '../utils';
-import * as GeneralStat from '../../formula/stats';
+import { calculateStatScore, StatsEnum } from './stats';
+import { calculateRoleScore } from './role';
 export class Stat {
     constructor({ name, value }) {
         this.name = name;
@@ -29,16 +29,16 @@ export class Player {
         this.roles = roles;
         this.traits = traits;
         this.rarity = rarity;
-        this.generalStats = GeneralStat.ALL_STATS.map(stat => ({
+        this.generalStats = Object.values(StatsEnum).map((stat) => ({
             name: stat,
-            value: GeneralStat.calculateScore(stats, stat)
+            value: calculateStatScore(stats, stat)
         }));
     }
     // Used as a base sorting function for players
     static sortPlayers(roles) {
         return (p1, p2) => roles.reduce((x, role) => {
-            const p2Score = Role.calculateScore(p2.stats, role);
-            const p1Score = Role.calculateScore(p1.stats, role);
+            const p2Score = calculateRoleScore(p2.stats, role);
+            const p1Score = calculateRoleScore(p1.stats, role);
             return x + p2Score - p1Score;
         }, 0);
     }
@@ -46,17 +46,23 @@ export class Player {
         const compareFn = (acc, current) => {
             let x = current.value;
             switch (current.name) {
-                case 'ATTACK':
-                    x *= 0.35;
+                case StatsEnum.ATTACK:
+                    x *= 0.19;
                     break;
-                case 'DEFENSE':
-                    x *= 0.35;
+                case StatsEnum.SET:
+                    x *= 0.19;
                     break;
-                case 'SERVE':
-                    x *= 0.2;
+                case StatsEnum.RECEIVE:
+                    x *= 0.19;
                     break;
-                case 'PHYSICAL':
-                    x *= 0.1;
+                case StatsEnum.BLOCK:
+                    x *= 0.19;
+                    break;
+                case StatsEnum.SERVE:
+                    x *= 0.19;
+                    break;
+                case StatsEnum.STAMINA:
+                    x *= 0.05;
                     break;
                 default:
                     x *= 0;
@@ -67,9 +73,6 @@ export class Player {
         const s2 = p2.generalStats.reduce(compareFn, 0);
         return s2 - s1;
     }
-    canPlayLibero() {
-        return this.roles.includes(Role.LIBERO);
-    }
     toString() {
         return JSON.stringify({
             id: this.id,
@@ -78,7 +81,7 @@ export class Player {
             stats: this.stats.toString(),
             rarity: this.rarity,
             roles: `[${this.roles.map(r => r.toString()).join(',')}]`,
-            traits: `[${this.traits.map(r => r.toString()).join(',')}]`,
+            traits: `[${this.traits.map(t => t.toString()).join(',')}]`,
             generalStats: `[${this.generalStats.map(r => r.toString()).join(',')}]`
         });
     }

package/dist/esm/src/service/player/rarity.d.ts

@@ -1,10 +1,12 @@
-export declare enum Rarity {
+import { EnumDataType } from 'sequelize';
+export declare enum RarityEnum {
     COMMON = "COMMON",
     RARE = "RARE",
     LEGENDARY = "LEGENDARY",
     MYTHIC = "MYTHIC",
     SPECIAL = "SPECIAL"
 }
+export type Rarity = RarityEnum.COMMON | RarityEnum.RARE | RarityEnum.LEGENDARY | RarityEnum.MYTHIC | RarityEnum.SPECIAL;
 export declare const RarityRanges: {
     COMMON: number[];
     RARE: number[];
@@ -12,3 +14,4 @@ export declare const RarityRanges: {
     MYTHIC: number[];
     SPECIAL: number[];
 };
+export declare const RarityDataType: EnumDataType<RarityEnum>;

package/dist/esm/src/service/player/rarity.js

@@ -1,15 +1,17 @@
-export var Rarity;
-(function (Rarity) {
-    Rarity["COMMON"] = "COMMON";
-    Rarity["RARE"] = "RARE";
-    Rarity["LEGENDARY"] = "LEGENDARY";
-    Rarity["MYTHIC"] = "MYTHIC";
-    Rarity["SPECIAL"] = "SPECIAL";
-})(Rarity || (Rarity = {}));
+import { DataTypes } from 'sequelize';
+export var RarityEnum;
+(function (RarityEnum) {
+    RarityEnum["COMMON"] = "COMMON";
+    RarityEnum["RARE"] = "RARE";
+    RarityEnum["LEGENDARY"] = "LEGENDARY";
+    RarityEnum["MYTHIC"] = "MYTHIC";
+    RarityEnum["SPECIAL"] = "SPECIAL";
+})(RarityEnum || (RarityEnum = {}));
 export const RarityRanges = {
-    [Rarity.COMMON]: [0, 50],
-    [Rarity.RARE]: [51, 70],
-    [Rarity.LEGENDARY]: [71, 85],
-    [Rarity.MYTHIC]: [86, 98],
-    [Rarity.SPECIAL]: [99, 100]
+    [RarityEnum.COMMON]: [0, 50],
+    [RarityEnum.RARE]: [51, 70],
+    [RarityEnum.LEGENDARY]: [71, 85],
+    [RarityEnum.MYTHIC]: [86, 98],
+    [RarityEnum.SPECIAL]: [99, 100]
 };
+export const RarityDataType = DataTypes.ENUM(...Object.values(RarityEnum));

package/dist/esm/src/service/player/role.d.ts

@@ -1,16 +1,17 @@
-import { Roles } from '../../formula';
-import { PerformanceStats } from './performance-stats';
-export declare class Role {
-    static readonly SETTER: Role;
-    static readonly LIBERO: Role;
-    static readonly OUTSIDE_HITTER: Role;
-    static readonly OPPOSITE_HITTER: Role;
-    static readonly MIDDLE_BLOCKER: Role;
-    private static readonly ROLES;
-    readonly name: Roles;
-    private constructor();
-    toString(): string;
-    static getRoles(): Role[];
-    static calculateScore(stats: PerformanceStats, role: Role): number;
-    static assignRoles(stats: PerformanceStats): Role[];
+import { EnumDataType } from 'sequelize';
+import { PerformanceStats, PerformanceStatsParams } from './performance-stats';
+export declare enum RoleEnum {
+    SETTER = "SETTER",
+    LIBERO = "LIBERO",
+    OUTSIDE_HITTER = "OUTSIDE_HITTER",
+    OPPOSITE_HITTER = "OPPOSITE_HITTER",
+    MIDDLE_BLOCKER = "MIDDLE_BLOCKER"
 }
+export type Role = RoleEnum.SETTER | RoleEnum.LIBERO | RoleEnum.MIDDLE_BLOCKER | RoleEnum.OUTSIDE_HITTER | RoleEnum.OPPOSITE_HITTER;
+export declare const RoleDataType: EnumDataType<Role>;
+export interface RolesFormula {
+    role: Role;
+    weight: PerformanceStatsParams;
+}
+export declare function calculateRoleScore(stats: PerformanceStats, role: Role): number;
+export declare function assignRoles(stats: PerformanceStats): Role[];