volleyballsimtypes 0.0.82 → 0.0.84

package/dist/esm/src/data/models/tournament-match.d.ts

@@ -1,29 +1,29 @@
-import * as Sequelize from 'sequelize';
-import { Model } from 'sequelize';
-import type { MatchAttributes, MatchId, MatchModel, TournamentId, TournamentModel } from '.';
-export interface TournamentMatchAttributes {
-    tournament_id: string;
-    match_id: string;
-    index: number;
-    stage: TournamentStage;
-    match?: MatchAttributes;
-}
-export type TournamentStage = 'ROUND_OF_8' | 'QUARTERFINALS' | 'SEMIFINALS' | 'FINAL';
-export type TournamentMatchPk = 'match_id';
-export type TournamentMatchId = TournamentMatchModel[TournamentMatchPk];
-export type TournamentMatchCreationAttributes = TournamentMatchAttributes;
-export declare class TournamentMatchModel extends Model<TournamentMatchAttributes, TournamentMatchCreationAttributes> implements TournamentMatchAttributes {
-    tournament_id: string;
-    match_id: string;
-    index: number;
-    stage: TournamentStage;
-    match: MatchModel;
-    getMatch: Sequelize.BelongsToGetAssociationMixin<MatchModel>;
-    setMatch: Sequelize.BelongsToSetAssociationMixin<MatchModel, MatchId>;
-    createMatch: Sequelize.BelongsToCreateAssociationMixin<MatchModel>;
-    tournament: TournamentModel;
-    getTournament: Sequelize.BelongsToGetAssociationMixin<TournamentModel>;
-    setTournament: Sequelize.BelongsToSetAssociationMixin<TournamentModel, TournamentId>;
-    createTournament: Sequelize.BelongsToCreateAssociationMixin<TournamentModel>;
-    static initModel(sequelize: Sequelize.Sequelize): typeof TournamentMatchModel;
-}
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import type { MatchAttributes, MatchId, MatchModel, TournamentId, TournamentModel } from '.';
+export interface TournamentMatchAttributes {
+    tournament_id: string;
+    match_id: string;
+    index: number;
+    stage: TournamentStage;
+    match?: MatchAttributes;
+}
+export type TournamentStage = 'ROUND_OF_8' | 'QUARTERFINALS' | 'SEMIFINALS' | 'FINAL';
+export type TournamentMatchPk = 'match_id';
+export type TournamentMatchId = TournamentMatchModel[TournamentMatchPk];
+export type TournamentMatchCreationAttributes = TournamentMatchAttributes;
+export declare class TournamentMatchModel extends Model<TournamentMatchAttributes, TournamentMatchCreationAttributes> implements TournamentMatchAttributes {
+    tournament_id: string;
+    match_id: string;
+    index: number;
+    stage: TournamentStage;
+    match: MatchModel;
+    getMatch: Sequelize.BelongsToGetAssociationMixin<MatchModel>;
+    setMatch: Sequelize.BelongsToSetAssociationMixin<MatchModel, MatchId>;
+    createMatch: Sequelize.BelongsToCreateAssociationMixin<MatchModel>;
+    tournament: TournamentModel;
+    getTournament: Sequelize.BelongsToGetAssociationMixin<TournamentModel>;
+    setTournament: Sequelize.BelongsToSetAssociationMixin<TournamentModel, TournamentId>;
+    createTournament: Sequelize.BelongsToCreateAssociationMixin<TournamentModel>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof TournamentMatchModel;
+}

package/dist/esm/src/data/models/tournament-match.js

@@ -1,42 +1,42 @@
-import { DataTypes, Model } from 'sequelize';
-export class TournamentMatchModel extends Model {
-    static initModel(sequelize) {
-        return TournamentMatchModel.init({
-            tournament_id: {
-                type: DataTypes.UUID,
-                allowNull: false,
-                references: {
-                    model: 'Tournament',
-                    key: 'tournament_id'
-                }
-            },
-            match_id: {
-                type: DataTypes.UUID,
-                allowNull: false,
-                primaryKey: true,
-                references: {
-                    model: 'Match',
-                    key: 'match_id'
-                }
-            },
-            index: {
-                type: DataTypes.INTEGER,
-                allowNull: false
-            },
-            stage: {
-                type: DataTypes.ENUM('FINAL', 'QUARTERFINALS', 'ROUND_OF_8', 'SEMIFINALS'),
-                allowNull: false
-            }
-        }, {
-            sequelize,
-            tableName: 'TournamentMatch',
-            schema: 'public',
-            timestamps: false,
-            indexes: [{
-                    name: 'TournamentMatch_match_id_uindex',
-                    unique: true,
-                    fields: [{ name: 'match_id' }]
-                }]
-        });
-    }
-}
+import { DataTypes, Model } from 'sequelize';
+export class TournamentMatchModel extends Model {
+    static initModel(sequelize) {
+        return TournamentMatchModel.init({
+            tournament_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'Tournament',
+                    key: 'tournament_id'
+                }
+            },
+            match_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'Match',
+                    key: 'match_id'
+                }
+            },
+            index: {
+                type: DataTypes.INTEGER,
+                allowNull: false
+            },
+            stage: {
+                type: DataTypes.ENUM('FINAL', 'QUARTERFINALS', 'ROUND_OF_8', 'SEMIFINALS'),
+                allowNull: false
+            }
+        }, {
+            sequelize,
+            tableName: 'TournamentMatch',
+            schema: 'public',
+            timestamps: false,
+            indexes: [{
+                    name: 'TournamentMatch_match_id_uindex',
+                    unique: true,
+                    fields: [{ name: 'match_id' }]
+                }]
+        });
+    }
+}

package/dist/esm/src/data/models/tournament-teams.d.ts

@@ -1,23 +1,23 @@
-import * as Sequelize from 'sequelize';
-import { Model } from 'sequelize';
-import type { TeamId, TeamModel, TournamentId, TournamentModel } from '.';
-export interface TournamentTeamsAttributes {
-    tournament_id: string;
-    team_id: string;
-}
-export type TournamentTeamsPk = 'tournament_id' | 'team_id';
-export type TournamentTeamsId = TournamentTeamsModel[TournamentTeamsPk];
-export type TournamentTeamsCreationAttributes = TournamentTeamsAttributes;
-export declare class TournamentTeamsModel extends Model<TournamentTeamsAttributes, TournamentTeamsCreationAttributes> implements TournamentTeamsAttributes {
-    tournament_id: string;
-    team_id: string;
-    tournament: TournamentModel;
-    getTournament: Sequelize.BelongsToGetAssociationMixin<TournamentModel>;
-    setTournament: Sequelize.BelongsToSetAssociationMixin<TournamentModel, TournamentId>;
-    createTournament: Sequelize.BelongsToCreateAssociationMixin<TournamentModel>;
-    team: TeamModel;
-    getTeam: Sequelize.BelongsToGetAssociationMixin<TeamModel>;
-    setTeam: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>;
-    createTeam: Sequelize.BelongsToCreateAssociationMixin<TeamModel>;
-    static initModel(sequelize: Sequelize.Sequelize): typeof TournamentTeamsModel;
-}
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import type { TeamId, TeamModel, TournamentId, TournamentModel } from '.';
+export interface TournamentTeamsAttributes {
+    tournament_id: string;
+    team_id: string;
+}
+export type TournamentTeamsPk = 'tournament_id' | 'team_id';
+export type TournamentTeamsId = TournamentTeamsModel[TournamentTeamsPk];
+export type TournamentTeamsCreationAttributes = TournamentTeamsAttributes;
+export declare class TournamentTeamsModel extends Model<TournamentTeamsAttributes, TournamentTeamsCreationAttributes> implements TournamentTeamsAttributes {
+    tournament_id: string;
+    team_id: string;
+    tournament: TournamentModel;
+    getTournament: Sequelize.BelongsToGetAssociationMixin<TournamentModel>;
+    setTournament: Sequelize.BelongsToSetAssociationMixin<TournamentModel, TournamentId>;
+    createTournament: Sequelize.BelongsToCreateAssociationMixin<TournamentModel>;
+    team: TeamModel;
+    getTeam: Sequelize.BelongsToGetAssociationMixin<TeamModel>;
+    setTeam: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>;
+    createTeam: Sequelize.BelongsToCreateAssociationMixin<TeamModel>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof TournamentTeamsModel;
+}

package/dist/esm/src/data/models/tournament-teams.js

@@ -1,40 +1,40 @@
-import { DataTypes, Model } from 'sequelize';
-export class TournamentTeamsModel extends Model {
-    static initModel(sequelize) {
-        return TournamentTeamsModel.init({
-            tournament_id: {
-                type: DataTypes.UUID,
-                allowNull: false,
-                primaryKey: true,
-                references: {
-                    model: 'Tournament',
-                    key: 'tournament_id'
-                }
-            },
-            team_id: {
-                type: DataTypes.UUID,
-                allowNull: false,
-                primaryKey: true,
-                references: {
-                    model: 'Team',
-                    key: 'team_id'
-                }
-            }
-        }, {
-            sequelize,
-            tableName: 'TournamentTeams',
-            schema: 'public',
-            timestamps: false,
-            indexes: [
-                {
-                    name: 'TournamentTeams_pk',
-                    unique: true,
-                    fields: [
-                        { name: 'tournament_id' },
-                        { name: 'team_id' }
-                    ]
-                }
-            ]
-        });
-    }
-}
+import { DataTypes, Model } from 'sequelize';
+export class TournamentTeamsModel extends Model {
+    static initModel(sequelize) {
+        return TournamentTeamsModel.init({
+            tournament_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'Tournament',
+                    key: 'tournament_id'
+                }
+            },
+            team_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'Team',
+                    key: 'team_id'
+                }
+            }
+        }, {
+            sequelize,
+            tableName: 'TournamentTeams',
+            schema: 'public',
+            timestamps: false,
+            indexes: [
+                {
+                    name: 'TournamentTeams_pk',
+                    unique: true,
+                    fields: [
+                        { name: 'tournament_id' },
+                        { name: 'team_id' }
+                    ]
+                }
+            ]
+        });
+    }
+}

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

@@ -1,62 +1,62 @@
-import * as Sequelize from 'sequelize';
-import { Model, Optional } from 'sequelize';
-import type { IterationId, TeamId, TeamModel, TournamentMatchAttributes, TournamentMatchId, TournamentMatchModel, TournamentTeamsId } from '.';
-import { IterationModel, TeamAttributes, TournamentTeamsModel } from '.';
-export interface TournamentAttributes {
-    tournament_id: string;
-    iteration: number;
-    champion?: string;
-    TournamentMatches?: TournamentMatchAttributes[];
-    tournamentTeams?: TeamAttributes[];
-}
-export type TournamentPk = 'tournament_id';
-export type TournamentId = TournamentModel[TournamentPk];
-export type TournamentOptionalAttributes = 'champion';
-export type TournamentCreationAttributes = Optional<TournamentAttributes, TournamentOptionalAttributes>;
-export declare class TournamentModel extends Model<TournamentAttributes, TournamentCreationAttributes> implements TournamentAttributes {
-    tournament_id: string;
-    iteration: number;
-    champion?: string;
-    tournamentTeams: TeamModel[];
-    Iteration: IterationModel;
-    getIteration: Sequelize.BelongsToGetAssociationMixin<IterationModel>;
-    setIteration: Sequelize.BelongsToSetAssociationMixin<IterationModel, IterationId>;
-    createIteration: Sequelize.BelongsToCreateAssociationMixin<IterationModel>;
-    Champion: TeamModel;
-    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>;
-    addTournamentMatches: Sequelize.HasManyAddAssociationsMixin<TournamentMatchModel, TournamentMatchId>;
-    createTournamentMatch: Sequelize.HasManyCreateAssociationMixin<TournamentMatchModel>;
-    removeTournamentMatch: Sequelize.HasManyRemoveAssociationMixin<TournamentMatchModel, TournamentMatchId>;
-    removeTournamentMatches: Sequelize.HasManyRemoveAssociationsMixin<TournamentMatchModel, TournamentMatchId>;
-    hasTournamentMatch: Sequelize.HasManyHasAssociationMixin<TournamentMatchModel, TournamentMatchId>;
-    hasTournamentMatches: Sequelize.HasManyHasAssociationsMixin<TournamentMatchModel, TournamentMatchId>;
-    countTournamentMatches: Sequelize.HasManyCountAssociationsMixin;
-    TournamentTeams: TournamentTeamsModel[];
-    getTournamentTeams: Sequelize.HasManyGetAssociationsMixin<TournamentTeamsModel>;
-    setTournamentTeams: Sequelize.HasManySetAssociationsMixin<TournamentTeamsModel, TournamentTeamsId>;
-    addTournamentTeam: Sequelize.HasManyAddAssociationMixin<TournamentTeamsModel, TournamentTeamsId>;
-    addTournamentTeams: Sequelize.HasManyAddAssociationsMixin<TournamentTeamsModel, TournamentTeamsId>;
-    createTournamentTeam: Sequelize.HasManyCreateAssociationMixin<TournamentTeamsModel>;
-    removeTournamentTeam: Sequelize.HasManyRemoveAssociationMixin<TournamentTeamsModel, TournamentTeamsId>;
-    removeTournamentTeams: Sequelize.HasManyRemoveAssociationsMixin<TournamentTeamsModel, TournamentTeamsId>;
-    hasTournamentTeam: Sequelize.HasManyHasAssociationMixin<TournamentTeamsModel, TournamentTeamsId>;
-    hasTournamentTeams: Sequelize.HasManyHasAssociationsMixin<TournamentTeamsModel, TournamentTeamsId>;
-    countTournamentTeams: Sequelize.HasManyCountAssociationsMixin;
-    gettournamentTeams: Sequelize.BelongsToManyGetAssociationsMixin<TeamModel>;
-    settournamentTeams: Sequelize.BelongsToManySetAssociationsMixin<TeamModel, TeamId>;
-    addTeam_id_Team: Sequelize.BelongsToManyAddAssociationMixin<TeamModel, TeamId>;
-    addtournamentTeams: Sequelize.BelongsToManyAddAssociationsMixin<TeamModel, TeamId>;
-    createTeam_id_Team: Sequelize.BelongsToManyCreateAssociationMixin<TeamModel>;
-    removeTeam_id_Team: Sequelize.BelongsToManyRemoveAssociationMixin<TeamModel, TeamId>;
-    removetournamentTeams: Sequelize.BelongsToManyRemoveAssociationsMixin<TeamModel, TeamId>;
-    hasTeam_id_Team: Sequelize.BelongsToManyHasAssociationMixin<TeamModel, TeamId>;
-    hastournamentTeams: Sequelize.BelongsToManyHasAssociationsMixin<TeamModel, TeamId>;
-    counttournamentTeams: Sequelize.BelongsToManyCountAssociationsMixin;
-    static initModel(sequelize: Sequelize.Sequelize): typeof TournamentModel;
-}
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { IterationId, TeamId, TeamModel, TournamentMatchAttributes, TournamentMatchId, TournamentMatchModel, TournamentTeamsId } from '.';
+import { IterationModel, TeamAttributes, TournamentTeamsModel } from '.';
+export interface TournamentAttributes {
+    tournament_id: string;
+    iteration: number;
+    champion?: string;
+    TournamentMatches?: TournamentMatchAttributes[];
+    tournamentTeams?: TeamAttributes[];
+}
+export type TournamentPk = 'tournament_id';
+export type TournamentId = TournamentModel[TournamentPk];
+export type TournamentOptionalAttributes = 'champion';
+export type TournamentCreationAttributes = Optional<TournamentAttributes, TournamentOptionalAttributes>;
+export declare class TournamentModel extends Model<TournamentAttributes, TournamentCreationAttributes> implements TournamentAttributes {
+    tournament_id: string;
+    iteration: number;
+    champion?: string;
+    TournamentMatches: TournamentMatchModel[];
+    tournamentTeams: TeamModel[];
+    Iteration: IterationModel;
+    getIteration: Sequelize.BelongsToGetAssociationMixin<IterationModel>;
+    setIteration: Sequelize.BelongsToSetAssociationMixin<IterationModel, IterationId>;
+    createIteration: Sequelize.BelongsToCreateAssociationMixin<IterationModel>;
+    Champion: TeamModel;
+    getChampion: Sequelize.BelongsToGetAssociationMixin<TeamModel>;
+    setChampion: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>;
+    createChampion: Sequelize.BelongsToCreateAssociationMixin<TeamModel>;
+    getTournamentMatches: Sequelize.HasManyGetAssociationsMixin<TournamentMatchModel>;
+    setTournamentMatches: Sequelize.HasManySetAssociationsMixin<TournamentMatchModel, TournamentMatchId>;
+    addTournamentMatch: Sequelize.HasManyAddAssociationMixin<TournamentMatchModel, TournamentMatchId>;
+    addTournamentMatches: Sequelize.HasManyAddAssociationsMixin<TournamentMatchModel, TournamentMatchId>;
+    createTournamentMatch: Sequelize.HasManyCreateAssociationMixin<TournamentMatchModel>;
+    removeTournamentMatch: Sequelize.HasManyRemoveAssociationMixin<TournamentMatchModel, TournamentMatchId>;
+    removeTournamentMatches: Sequelize.HasManyRemoveAssociationsMixin<TournamentMatchModel, TournamentMatchId>;
+    hasTournamentMatch: Sequelize.HasManyHasAssociationMixin<TournamentMatchModel, TournamentMatchId>;
+    hasTournamentMatches: Sequelize.HasManyHasAssociationsMixin<TournamentMatchModel, TournamentMatchId>;
+    countTournamentMatches: Sequelize.HasManyCountAssociationsMixin;
+    TournamentTeams: TournamentTeamsModel[];
+    getTournamentTeams: Sequelize.HasManyGetAssociationsMixin<TournamentTeamsModel>;
+    setTournamentTeams: Sequelize.HasManySetAssociationsMixin<TournamentTeamsModel, TournamentTeamsId>;
+    addTournamentTeam: Sequelize.HasManyAddAssociationMixin<TournamentTeamsModel, TournamentTeamsId>;
+    addTournamentTeams: Sequelize.HasManyAddAssociationsMixin<TournamentTeamsModel, TournamentTeamsId>;
+    createTournamentTeam: Sequelize.HasManyCreateAssociationMixin<TournamentTeamsModel>;
+    removeTournamentTeam: Sequelize.HasManyRemoveAssociationMixin<TournamentTeamsModel, TournamentTeamsId>;
+    removeTournamentTeams: Sequelize.HasManyRemoveAssociationsMixin<TournamentTeamsModel, TournamentTeamsId>;
+    hasTournamentTeam: Sequelize.HasManyHasAssociationMixin<TournamentTeamsModel, TournamentTeamsId>;
+    hasTournamentTeams: Sequelize.HasManyHasAssociationsMixin<TournamentTeamsModel, TournamentTeamsId>;
+    countTournamentTeams: Sequelize.HasManyCountAssociationsMixin;
+    gettournamentTeams: Sequelize.BelongsToManyGetAssociationsMixin<TeamModel>;
+    settournamentTeams: Sequelize.BelongsToManySetAssociationsMixin<TeamModel, TeamId>;
+    addTeam_id_Team: Sequelize.BelongsToManyAddAssociationMixin<TeamModel, TeamId>;
+    addtournamentTeams: Sequelize.BelongsToManyAddAssociationsMixin<TeamModel, TeamId>;
+    createTeam_id_Team: Sequelize.BelongsToManyCreateAssociationMixin<TeamModel>;
+    removeTeam_id_Team: Sequelize.BelongsToManyRemoveAssociationMixin<TeamModel, TeamId>;
+    removetournamentTeams: Sequelize.BelongsToManyRemoveAssociationsMixin<TeamModel, TeamId>;
+    hasTeam_id_Team: Sequelize.BelongsToManyHasAssociationMixin<TeamModel, TeamId>;
+    hastournamentTeams: Sequelize.BelongsToManyHasAssociationsMixin<TeamModel, TeamId>;
+    counttournamentTeams: Sequelize.BelongsToManyCountAssociationsMixin;
+    static initModel(sequelize: Sequelize.Sequelize): typeof TournamentModel;
+}

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

@@ -1,45 +1,45 @@
-import { DataTypes, Model } from 'sequelize';
-export class TournamentModel extends Model {
-    static initModel(sequelize) {
-        return TournamentModel.init({
-            tournament_id: {
-                type: DataTypes.UUID,
-                allowNull: false,
-                primaryKey: true
-            },
-            iteration: {
-                type: DataTypes.INTEGER,
-                allowNull: false,
-                references: {
-                    model: 'Iteration',
-                    key: 'iteration'
-                }
-            },
-            champion: {
-                type: DataTypes.UUID,
-                allowNull: true,
-                references: {
-                    model: 'Team',
-                    key: 'team_id'
-                }
-            }
-        }, {
-            sequelize,
-            tableName: 'Tournament',
-            schema: 'public',
-            timestamps: false,
-            indexes: [
-                {
-                    name: 'Tournament_pk',
-                    unique: true,
-                    fields: [{ name: 'tournament_id' }]
-                },
-                {
-                    name: 'Tournament_unique',
-                    unique: true,
-                    fields: [{ name: 'iteration' }]
-                }
-            ]
-        });
-    }
-}
+import { DataTypes, Model } from 'sequelize';
+export class TournamentModel extends Model {
+    static initModel(sequelize) {
+        return TournamentModel.init({
+            tournament_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true
+            },
+            iteration: {
+                type: DataTypes.INTEGER,
+                allowNull: false,
+                references: {
+                    model: 'Iteration',
+                    key: 'iteration'
+                }
+            },
+            champion: {
+                type: DataTypes.UUID,
+                allowNull: true,
+                references: {
+                    model: 'Team',
+                    key: 'team_id'
+                }
+            }
+        }, {
+            sequelize,
+            tableName: 'Tournament',
+            schema: 'public',
+            timestamps: false,
+            indexes: [
+                {
+                    name: 'Tournament_pk',
+                    unique: true,
+                    fields: [{ name: 'tournament_id' }]
+                },
+                {
+                    name: 'Tournament_unique',
+                    unique: true,
+                    fields: [{ name: 'iteration' }]
+                }
+            ]
+        });
+    }
+}

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' }]
+                }]
+        });
+    }
+}