volleyballsimtypes 0.0.166 → 0.0.168

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[];

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

@@ -1,40 +1,40 @@
-import { rolesFormula } from '../../formula';
-export class Role {
-    constructor(name) {
-        this.name = name;
-    }
-    toString() {
-        return this.name;
-    }
-    static getRoles() {
-        return [...Role.ROLES];
-    }
-    static calculateScore(stats, role) {
-        const weights = rolesFormula.find(r => r.role === role.name);
-        if (weights == null)
-            throw new Error('COULD_NOT_FIND_ROLE_WEIGHT');
-        const score = Object.entries(weights.weight)
-            .reduce((score, [key, value]) => score + (stats[key] * weights.weight[key]), 0);
-        return Math.round(score);
+import { DataTypes } from 'sequelize';
+import roles from '../../stat-config/roles.json';
+export var RoleEnum;
+(function (RoleEnum) {
+    RoleEnum["SETTER"] = "SETTER";
+    RoleEnum["LIBERO"] = "LIBERO";
+    RoleEnum["OUTSIDE_HITTER"] = "OUTSIDE_HITTER";
+    RoleEnum["OPPOSITE_HITTER"] = "OPPOSITE_HITTER";
+    RoleEnum["MIDDLE_BLOCKER"] = "MIDDLE_BLOCKER";
+})(RoleEnum || (RoleEnum = {}));
+export const RoleDataType = DataTypes.ENUM(...Object.values(RoleEnum));
+const rolesFormula = roles;
+export function calculateRoleScore(stats, role) {
+    const weights = rolesFormula.find(r => r.role === role);
+    if (weights == null)
+        throw new Error('COULD_NOT_FIND_ROLE_WEIGHT');
+    const score = Object.keys(weights.weight)
+        .reduce((score, key) => {
+        const stat = stats[key];
+        const weight = weights.weight[key];
+        return score + (stat * weight);
+    }, 0);
+    return Math.round(score);
+}
+export function assignRoles(stats) {
+    const scores = Object.values(RoleEnum)
+        .map((role) => ({
+        role,
+        score: calculateRoleScore(stats, role)
+    }))
+        .sort((x, y) => y.score - x.score);
+    const out = [scores[0].role];
+    if (scores[1].score >= 75) {
+        out.push(scores[1].role);
     }
-    static assignRoles(stats) {
-        const scores = this.getRoles().map(role => ({
-            role,
-            score: this.calculateScore(stats, role)
-        })).sort((x, y) => y.score - x.score);
-        const out = [scores[0].role];
-        if (scores[1].score >= 75) {
-            out.push(scores[1].role);
-        }
-        if (scores[2].score >= 85) {
-            out.push(scores[2].role);
-        }
-        return out;
+    if (scores[2].score >= 85) {
+        out.push(scores[2].role);
     }
+    return out;
 }
-Role.SETTER = new Role('SETTER');
-Role.LIBERO = new Role('LIBERO');
-Role.OUTSIDE_HITTER = new Role('OUTSIDE_HITTER');
-Role.OPPOSITE_HITTER = new Role('OPPOSITE_HITTER');
-Role.MIDDLE_BLOCKER = new Role('MIDDLE_BLOCKER');
-Role.ROLES = [Role.LIBERO, Role.SETTER, Role.OPPOSITE_HITTER, Role.OUTSIDE_HITTER, Role.MIDDLE_BLOCKER];

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

@@ -0,0 +1,12 @@
+import { PerformanceStats } from './performance-stats';
+export declare enum StatsEnum {
+    ATTACK = "ATTACK",
+    SET = "SET",
+    RECEIVE = "RECEIVE",
+    SERVE = "SERVE",
+    BLOCK = "BLOCK",
+    STAMINA = "STAMINA"
+}
+export type Stats = StatsEnum.ATTACK | StatsEnum.SET | StatsEnum.RECEIVE | StatsEnum.SERVE | StatsEnum.BLOCK | StatsEnum.STAMINA;
+export declare function calculateStatScore(performanceStats: PerformanceStats, statName: Stats): number;
+export declare function getMultipliers(statName: Stats, performanceStats?: PerformanceStats): any;

package/dist/esm/src/{formula → service/player}/stats.js

@@ -1,5 +1,13 @@
-export const ALL_STATS = ['ATTACK', 'SET', 'RECEIVE', 'SERVE', 'BLOCK', 'STAMINA'];
-export function calculateScore(performanceStats, statName) {
+export var StatsEnum;
+(function (StatsEnum) {
+    StatsEnum["ATTACK"] = "ATTACK";
+    StatsEnum["SET"] = "SET";
+    StatsEnum["RECEIVE"] = "RECEIVE";
+    StatsEnum["SERVE"] = "SERVE";
+    StatsEnum["BLOCK"] = "BLOCK";
+    StatsEnum["STAMINA"] = "STAMINA";
+})(StatsEnum || (StatsEnum = {}));
+export function calculateStatScore(performanceStats, statName) {
     const multipliers = getMultipliers(statName, performanceStats);
     const score = Object.entries(multipliers)
         .reduce((total, [key, value]) => total + value * performanceStats[key], 0);
@@ -7,7 +15,7 @@ export function calculateScore(performanceStats, statName) {
 }
 export function getMultipliers(statName, performanceStats) {
     switch (statName) {
-        case 'ATTACK':
+        case StatsEnum.ATTACK:
             return {
                 spike: 0.55,
                 backAttack: 0.1,
@@ -16,7 +24,7 @@ export function getMultipliers(statName, performanceStats) {
                 awareness: 0.05,
                 attack: 0.05
             };
-        case 'SET':
+        case StatsEnum.SET:
             return {
                 setting: 0.7,
                 overhand: 0.1,
@@ -24,7 +32,7 @@ export function getMultipliers(statName, performanceStats) {
                 awareness: 0.075,
                 attack: 0.075
             };
-        case 'RECEIVE':
+        case StatsEnum.RECEIVE:
             return {
                 reception: 0.75,
                 overhand: 0.025,
@@ -32,13 +40,13 @@ export function getMultipliers(statName, performanceStats) {
                 focus: 0.025,
                 defense: 0.05
             };
-        case 'SERVE':
+        case StatsEnum.SERVE:
             return {
                 serve: 0.85,
                 awareness: 0.075,
                 attack: 0.075
             };
-        case 'BLOCK':
+        case StatsEnum.BLOCK:
             return {
                 block: 0.65,
                 read: performanceStats == null ? 0.125 : performanceStats.read > performanceStats.commit ? 0.2 : 0.05,
@@ -46,7 +54,7 @@ export function getMultipliers(statName, performanceStats) {
                 focus: 0.05,
                 defense: 0.05
             };
-        case 'STAMINA':
+        case StatsEnum.STAMINA:
             return { stamina: 1 };
         default:
             throw new Error('INVALID_STAT');

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

@@ -1,22 +1,26 @@
-import * as GeneralStat from '../../formula/stats';
 import { PerformanceStats } from './performance-stats';
 import { Rarity } from './rarity';
-export declare class Trait {
-    static readonly MASTER_MIND: Trait;
-    static readonly MOVING_WALL: Trait;
-    static readonly MARKSMAN: Trait;
-    static readonly METEOR_SERVE: Trait;
-    static readonly VIGOROUS: Trait;
-    static readonly GUARDIAN: Trait;
-    readonly id: string;
-    readonly name: string;
+import { EnumDataType } from 'sequelize';
+import { Stats } from './stats';
+interface TraitProps {
+    readonly name: Trait;
     readonly modifier: number;
     readonly chance: number;
     readonly statThreshold: number;
-    readonly stat: GeneralStat.Stats;
+    readonly stat: Stats;
     readonly weight: number;
-    private constructor();
-    static getTraits(): Trait[];
-    static assignTraits(performanceStats: PerformanceStats, rarity: Rarity): Trait[];
-    toString(): string;
 }
+export declare enum TraitEnum {
+    MASTER_MIND = "MASTER_MIND",
+    MOVING_WALL = "MOVING_WALL",
+    MARKSMAN = "MARKSMAN",
+    METEOR_SERVE = "METEOR_SERVE",
+    VIGOROUS = "VIGOROUS",
+    GUARDIAN = "GUARDIAN",
+    FLOAT_SERVE = "FLOAT_SERVE"
+}
+export type Trait = TraitEnum.FLOAT_SERVE | TraitEnum.GUARDIAN | TraitEnum.MASTER_MIND | TraitEnum.MOVING_WALL | TraitEnum.MARKSMAN | TraitEnum.METEOR_SERVE | TraitEnum.VIGOROUS;
+export declare const TraitDataType: EnumDataType<Trait>;
+export declare function assignTraits(performanceStats: PerformanceStats, rarity: Rarity): Trait[];
+export declare const traitMap: Map<Trait, TraitProps>;
+export {};

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

@@ -1,121 +1,51 @@
-import * as GeneralStat from '../../formula/stats';
-import { Rarity } from './rarity';
+import { RarityEnum } from './rarity';
 import { randomInt } from 'node:crypto';
-export class Trait {
-    constructor({ id, name, modifier, chance, statThreshold, stat, weight }) {
-        this.id = id;
-        this.name = name;
-        this.modifier = modifier;
-        this.chance = chance;
-        this.statThreshold = statThreshold;
-        this.stat = stat;
-        this.weight = weight;
-    }
-    static getTraits() {
-        return [Trait.GUARDIAN, Trait.MARKSMAN, Trait.METEOR_SERVE, Trait.VIGOROUS, Trait.MOVING_WALL, Trait.MASTER_MIND];
-    }
-    static assignTraits(performanceStats, rarity) {
-        let traitCount;
-        switch (rarity) {
-            case Rarity.COMMON: {
-                traitCount = 0;
-                break;
-            }
-            case Rarity.RARE: {
-                traitCount = randomInt(0, 1);
-                break;
-            }
-            case Rarity.LEGENDARY: {
-                traitCount = randomInt(0, 2);
-                break;
-            }
-            case Rarity.MYTHIC: {
-                traitCount = randomInt(1, 3);
-                break;
-            }
-            case Rarity.SPECIAL: {
-                traitCount = randomInt(2, 3);
-                break;
-            }
-            default:
-                throw new Error('INVALID_RARITY');
+import rawTraits from '../../stat-config/traits.json';
+import { DataTypes } from 'sequelize';
+import { calculateStatScore } from './stats';
+const traits = rawTraits;
+export var TraitEnum;
+(function (TraitEnum) {
+    TraitEnum["MASTER_MIND"] = "MASTER_MIND";
+    TraitEnum["MOVING_WALL"] = "MOVING_WALL";
+    TraitEnum["MARKSMAN"] = "MARKSMAN";
+    TraitEnum["METEOR_SERVE"] = "METEOR_SERVE";
+    TraitEnum["VIGOROUS"] = "VIGOROUS";
+    TraitEnum["GUARDIAN"] = "GUARDIAN";
+    TraitEnum["FLOAT_SERVE"] = "FLOAT_SERVE";
+})(TraitEnum || (TraitEnum = {}));
+export const TraitDataType = DataTypes.ENUM(...Object.values(TraitEnum));
+export function assignTraits(performanceStats, rarity) {
+    let traitCount;
+    switch (rarity) {
+        case RarityEnum.COMMON: {
+            traitCount = 0;
+            break;
         }
-        if (traitCount < 1)
-            return [];
-        const qualifiedTraits = this.getTraits()
-            .filter(trait => GeneralStat.calculateScore(performanceStats, trait.stat) >= trait.statThreshold);
-        return qualifiedTraits.sort((t1, t2) => t2.weight - t1.weight)
-            .slice(0, traitCount);
-    }
-    toString() {
-        return JSON.stringify({
-            name: this.name,
-            modifier: this.modifier,
-            statThreshold: this.statThreshold,
-            chance: this.chance,
-            stat: this.stat,
-            weight: this.weight
-        });
+        case RarityEnum.RARE: {
+            traitCount = randomInt(0, 1);
+            break;
+        }
+        case RarityEnum.LEGENDARY: {
+            traitCount = randomInt(0, 2);
+            break;
+        }
+        case RarityEnum.MYTHIC: {
+            traitCount = randomInt(1, 3);
+            break;
+        }
+        case RarityEnum.SPECIAL: {
+            traitCount = randomInt(2, 3);
+            break;
+        }
+        default:
+            throw new Error('INVALID_RARITY');
     }
+    if (traitCount < 1)
+        return [];
+    return traits.filter((trait) => calculateStatScore(performanceStats, trait.stat) >= trait.statThreshold)
+        .sort((t1, t2) => t2.weight - t1.weight)
+        .map((trait) => trait.name)
+        .slice(0, traitCount);
 }
-// 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',
-    modifier: 1.1,
-    chance: 0.2,
-    statThreshold: 80,
-    stat: 'ATTACK',
-    weight: 10
-});
-// Will always participate in blocking regardless of chance and adds
-Trait.MOVING_WALL = new Trait({
-    id: '304c53f6-5e7a-44d3-9625-f10d8109421a',
-    name: 'Moving Wall',
-    modifier: 1.1,
-    chance: 1,
-    statThreshold: 75,
-    stat: 'DEFENSE',
-    weight: 5
-});
-// 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',
-    modifier: 1.05,
-    chance: 0.3,
-    statThreshold: 75,
-    stat: 'ATTACK',
-    weight: 5
-});
-// Increases the score of the serve by 10% when serve type is Jumping.
-Trait.METEOR_SERVE = new Trait({
-    id: 'c929a79d-5866-40d6-bbd6-b0b67a929c4c',
-    name: 'Meteor Serve',
-    modifier: 1.1,
-    chance: 0.1,
-    statThreshold: 75,
-    stat: 'SERVE',
-    weight: 10
-});
-// Has a 50% chance of taking an action without decreasing energy.
-Trait.VIGOROUS = new Trait({
-    id: 'f9599b87-b3b2-49ce-8224-470f6fe6ed64',
-    name: 'Vigorous',
-    modifier: 1,
-    statThreshold: 60,
-    chance: 0.5,
-    stat: 'PHYSICAL',
-    weight: 1
-});
-// Takes place of the receiver and increases reception score by 15%, guaranteeing success. Can only trigger in back-row.
-Trait.GUARDIAN = new Trait({
-    id: 'c3291953-9256-4559-b5a9-955ccb8f9a6f',
-    name: 'Guardian',
-    chance: 0.2,
-    statThreshold: 75,
-    modifier: 1.15,
-    stat: 'DEFENSE',
-    weight: 10
-});
+export const traitMap = new Map(traits.map((trait) => [trait.name, trait]));

package/dist/esm/src/{formula/role.formula.json → stat-config/roles.json}

@@ -18,7 +18,8 @@
             "read": 0,
             "commit": 0,
             "focus": 0,
-            "defense": 0
+            "defense": 0,
+            "saving": 0
         }
     },
     {
@@ -40,7 +41,8 @@
             "read": 0,
             "commit": 0,
             "focus": 0,
-            "defense": 0
+            "defense": 0,
+            "saving": 0
         }
     },
     {
@@ -62,7 +64,8 @@
             "read": 0,
             "commit": 0,
             "focus": 0,
-            "defense": 0
+            "defense": 0,
+            "saving": 0
         }
     },
     {
@@ -84,7 +87,8 @@
             "read": 0,
             "commit": 0,
             "focus": 0,
-            "defense": 0
+            "defense": 0,
+            "saving": 0
         }
     },
     {
@@ -106,7 +110,8 @@
             "read": 0,
             "commit": 0,
             "focus": 0,
-            "defense": 0
+            "defense": 0,
+            "saving": 0
         }
     }
 ]

package/dist/esm/src/stat-config/traits.json

@@ -0,0 +1,58 @@
+[
+    {
+        "name": "MASTER_MIND",
+        "modifier": 1.1,
+        "chance": 0.2,
+        "statThreshold": 80,
+        "stat": "SET",
+        "weight": 10
+    },
+    {
+        "name": "MOVING_WALL",
+        "modifier": 1.1,
+        "chance": 1,
+        "statThreshold": 75,
+        "stat": "BLOCK",
+        "weight": 5
+    },
+    {
+        "name": "MARKSMAN",
+        "modifier": 1.05,
+        "chance": 0.3,
+        "statThreshold": 75,
+        "stat": "ATTACK",
+        "weight": 5
+    },
+    {
+        "name": "METEOR_SERVE",
+        "modifier": 1.1,
+        "chance": 0.1,
+        "statThreshold": 75,
+        "stat": "SERVE",
+        "weight": 10
+    },
+    {
+        "name": "FLOAT_SERVE",
+        "modifier": 1,
+        "chance": 0.5,
+        "statThreshold": 60,
+        "stat": "SERVE",
+        "weight": 10
+    },
+    {
+        "name": "VIGOROUS",
+        "modifier": 1,
+        "statThreshold": 60,
+        "chance": 0.5,
+        "stat": "STAMINA",
+        "weight": 1
+    },
+    {
+        "name": "GUARDIAN",
+        "chance": 0.2,
+        "statThreshold": 75,
+        "modifier": 1.15,
+        "stat": "RECEIVE",
+        "weight": 10
+    }
+]

package/package.json

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

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

@@ -1,23 +0,0 @@
-import * as Sequelize from 'sequelize';
-import { Model } from 'sequelize';
-import { 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

@@ -1,42 +0,0 @@
-"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/trait.d.ts

@@ -1,37 +0,0 @@
-import * as Sequelize from 'sequelize';
-import { Model } from 'sequelize';
-import { PlayerId, PlayerModel, PlayerTraitId, PlayerTraitModel } from '.';
-export interface TraitAttributes {
-    trait_id: string;
-    name: string;
-}
-export type TraitPk = 'trait_id';
-export type TraitId = TraitModel[TraitPk];
-export type TraitCreationAttributes = TraitAttributes;
-export declare class TraitModel extends Model<TraitAttributes, TraitCreationAttributes> implements TraitAttributes {
-    trait_id: string;
-    name: string;
-    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

@@ -1,30 +0,0 @@
-"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
-            }
-        }, {
-            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/role.d.ts

@@ -1,5 +0,0 @@
-import { Role } from '../../service';
-import { RoleType } from '../models';
-declare function transformToType(role: Role): RoleType;
-declare function transformFromType(role: RoleType): Role;
-export { transformToType as transformFromRole, transformFromType as transformToRole };