volleyballsimtypes 0.0.356 → 0.0.358

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

@@ -0,0 +1,151 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import { CompetitionChampionId, CompetitionChampionModel, CompetitionId, CompetitionModel, CompetitionTeamsId, CompetitionTeamsModel, CountryId, CountryModel, DivisionAttributes, DivisionId, DivisionModel, MatchId, MatchModel, MatchRatingId, MatchRatingModel, PlayerAttributes, PlayerId, PlayerModel, PlayerTeamId, PlayerTeamModel, RallyId, RallyModel, TacticsAttributes, TacticsId, TacticsModel } from '.';
+export interface TeamAttributes {
+    team_id: string;
+    name: string;
+    short_name: string;
+    rating: number;
+    active: boolean;
+    country_id?: string;
+    division_id: string;
+    tactics?: TacticsAttributes;
+    Players?: PlayerAttributes[];
+    Division?: DivisionAttributes;
+}
+export type TeamPk = 'team_id';
+export type TeamId = TeamModel[TeamPk];
+export type TeamOptionalAttributes = 'rating' | 'active';
+export type TeamCreationAttributes = Optional<TeamAttributes, TeamOptionalAttributes>;
+export declare class TeamModel extends Model<TeamAttributes, TeamCreationAttributes> implements TeamAttributes {
+    team_id: string;
+    name: string;
+    short_name: string;
+    country_id: string;
+    rating: number;
+    active: boolean;
+    division_id: string;
+    tactics: TacticsModel;
+    getTactics: Sequelize.HasOneGetAssociationMixin<TacticsModel>;
+    setTactics: Sequelize.HasOneSetAssociationMixin<TacticsModel, TacticsId>;
+    createTactics: Sequelize.HasOneCreateAssociationMixin<TacticsModel>;
+    country: CountryModel;
+    getCountry: Sequelize.BelongsToGetAssociationMixin<CountryModel>;
+    setCountry: Sequelize.BelongsToSetAssociationMixin<CountryModel, CountryId>;
+    createCountry: Sequelize.BelongsToCreateAssociationMixin<CountryModel>;
+    Competitions: CompetitionModel[];
+    getCompetitions: Sequelize.BelongsToManyGetAssociationsMixin<CompetitionModel>;
+    setCompetitions: Sequelize.BelongsToManySetAssociationsMixin<CompetitionModel, CompetitionId>;
+    addCompetition: Sequelize.BelongsToManyAddAssociationMixin<CompetitionModel, CompetitionId>;
+    addCompetitions: Sequelize.BelongsToManyAddAssociationsMixin<CompetitionModel, CompetitionId>;
+    createCompetition: Sequelize.BelongsToManyCreateAssociationMixin<CompetitionModel>;
+    removeCompetition: Sequelize.BelongsToManyRemoveAssociationMixin<CompetitionModel, CompetitionId>;
+    removeCompetitions: Sequelize.BelongsToManyRemoveAssociationsMixin<CompetitionModel, CompetitionId>;
+    hasCompetition: Sequelize.BelongsToManyHasAssociationMixin<CompetitionModel, CompetitionId>;
+    hasCompetitions: Sequelize.BelongsToManyHasAssociationsMixin<CompetitionModel, CompetitionId>;
+    countCompetitions: Sequelize.BelongsToManyCountAssociationsMixin;
+    CompetitionChampions: CompetitionChampionModel[];
+    getCompetitionChampions: Sequelize.HasManyGetAssociationsMixin<CompetitionChampionModel>;
+    setCompetitionChampions: Sequelize.HasManySetAssociationsMixin<CompetitionChampionModel, CompetitionChampionId>;
+    addCompetitionChampion: Sequelize.HasManyAddAssociationMixin<CompetitionChampionModel, CompetitionChampionId>;
+    addCompetitionChampions: Sequelize.HasManyAddAssociationsMixin<CompetitionChampionModel, CompetitionChampionId>;
+    createCompetitionChampion: Sequelize.HasManyCreateAssociationMixin<CompetitionChampionModel>;
+    removeCompetitionChampion: Sequelize.HasManyRemoveAssociationMixin<CompetitionChampionModel, CompetitionChampionId>;
+    removeCompetitionChampions: Sequelize.HasManyRemoveAssociationsMixin<CompetitionChampionModel, CompetitionChampionId>;
+    hasCompetitionChampion: Sequelize.HasManyHasAssociationMixin<CompetitionChampionModel, CompetitionChampionId>;
+    hasCompetitionChampions: Sequelize.HasManyHasAssociationsMixin<CompetitionChampionModel, CompetitionChampionId>;
+    countCompetitionChampions: Sequelize.HasManyCountAssociationsMixin;
+    CompetitionTeams: CompetitionTeamsModel[];
+    getCompetitionTeams: Sequelize.HasManyGetAssociationsMixin<CompetitionTeamsModel>;
+    setCompetitionTeams: Sequelize.HasManySetAssociationsMixin<CompetitionTeamsModel, CompetitionTeamsId>;
+    addCompetitionTeam: Sequelize.HasManyAddAssociationMixin<CompetitionTeamsModel, CompetitionTeamsId>;
+    addCompetitionTeams: Sequelize.HasManyAddAssociationsMixin<CompetitionTeamsModel, CompetitionTeamsId>;
+    createCompetitionTeam: Sequelize.HasManyCreateAssociationMixin<CompetitionTeamsModel>;
+    removeCompetitionTeam: Sequelize.HasManyRemoveAssociationMixin<CompetitionTeamsModel, CompetitionTeamsId>;
+    removeCompetitionTeams: Sequelize.HasManyRemoveAssociationsMixin<CompetitionTeamsModel, CompetitionTeamsId>;
+    hasCompetitionTeam: Sequelize.HasManyHasAssociationMixin<CompetitionTeamsModel, CompetitionTeamsId>;
+    hasCompetitionTeams: Sequelize.HasManyHasAssociationsMixin<CompetitionTeamsModel, CompetitionTeamsId>;
+    countCompetitionTeams: Sequelize.HasManyCountAssociationsMixin;
+    HomeMatches: MatchModel[];
+    getHomeMatches: Sequelize.HasManyGetAssociationsMixin<MatchModel>;
+    setHomeMatches: Sequelize.HasManySetAssociationsMixin<MatchModel, MatchId>;
+    addHomeMatch: Sequelize.HasManyAddAssociationMixin<MatchModel, MatchId>;
+    addHomeMatches: Sequelize.HasManyAddAssociationsMixin<MatchModel, MatchId>;
+    createHomeMatch: Sequelize.HasManyCreateAssociationMixin<MatchModel>;
+    removeHomeMatch: Sequelize.HasManyRemoveAssociationMixin<MatchModel, MatchId>;
+    removeHomeMatches: Sequelize.HasManyRemoveAssociationsMixin<MatchModel, MatchId>;
+    hasHomeMatch: Sequelize.HasManyHasAssociationMixin<MatchModel, MatchId>;
+    hasHomeMatches: Sequelize.HasManyHasAssociationsMixin<MatchModel, MatchId>;
+    countHomeMatches: Sequelize.HasManyCountAssociationsMixin;
+    AwayMatches: MatchModel[];
+    getAwayMatches: Sequelize.HasManyGetAssociationsMixin<MatchModel>;
+    setAwayMatches: Sequelize.HasManySetAssociationsMixin<MatchModel, MatchId>;
+    addAwayMatch: Sequelize.HasManyAddAssociationMixin<MatchModel, MatchId>;
+    addAwayMatches: Sequelize.HasManyAddAssociationsMixin<MatchModel, MatchId>;
+    createAwayMatch: Sequelize.HasManyCreateAssociationMixin<MatchModel>;
+    removeAwayMatch: Sequelize.HasManyRemoveAssociationMixin<MatchModel, MatchId>;
+    removeAwayMatches: Sequelize.HasManyRemoveAssociationsMixin<MatchModel, MatchId>;
+    hasAwayMatch: Sequelize.HasManyHasAssociationMixin<MatchModel, MatchId>;
+    hasAwayMatches: Sequelize.HasManyHasAssociationsMixin<MatchModel, MatchId>;
+    countAwayMatches: Sequelize.HasManyCountAssociationsMixin;
+    RatingMatches: MatchModel[];
+    getRatingMatches: Sequelize.BelongsToManyGetAssociationsMixin<MatchModel>;
+    setRatingMatches: Sequelize.BelongsToManySetAssociationsMixin<MatchModel, MatchId>;
+    addRatingMatch: Sequelize.BelongsToManyAddAssociationMixin<MatchModel, MatchId>;
+    addRatingMatches: Sequelize.BelongsToManyAddAssociationsMixin<MatchModel, MatchId>;
+    createRatingMatch: Sequelize.BelongsToManyCreateAssociationMixin<MatchModel>;
+    removeRatingMatch: Sequelize.BelongsToManyRemoveAssociationMixin<MatchModel, MatchId>;
+    removeRatingMatches: Sequelize.BelongsToManyRemoveAssociationsMixin<MatchModel, MatchId>;
+    hasRatingMatch: Sequelize.BelongsToManyHasAssociationMixin<MatchModel, MatchId>;
+    hasRatingMatches: Sequelize.BelongsToManyHasAssociationsMixin<MatchModel, MatchId>;
+    countRatingMatches: Sequelize.BelongsToManyCountAssociationsMixin;
+    Division: DivisionModel;
+    getDivision: Sequelize.BelongsToGetAssociationMixin<DivisionModel>;
+    setDivision: Sequelize.BelongsToSetAssociationMixin<DivisionModel, DivisionId>;
+    createDivision: Sequelize.BelongsToCreateAssociationMixin<DivisionModel>;
+    MatchRatings: MatchRatingModel[];
+    getMatchRatings: Sequelize.HasManyGetAssociationsMixin<MatchRatingModel>;
+    setMatchRatings: Sequelize.HasManySetAssociationsMixin<MatchRatingModel, MatchRatingId>;
+    addMatchRating: Sequelize.HasManyAddAssociationMixin<MatchRatingModel, MatchRatingId>;
+    addMatchRatings: Sequelize.HasManyAddAssociationsMixin<MatchRatingModel, MatchRatingId>;
+    createMatchRating: Sequelize.HasManyCreateAssociationMixin<MatchRatingModel>;
+    removeMatchRating: Sequelize.HasManyRemoveAssociationMixin<MatchRatingModel, MatchRatingId>;
+    removeMatchRatings: Sequelize.HasManyRemoveAssociationsMixin<MatchRatingModel, MatchRatingId>;
+    hasMatchRating: Sequelize.HasManyHasAssociationMixin<MatchRatingModel, MatchRatingId>;
+    hasMatchRatings: Sequelize.HasManyHasAssociationsMixin<MatchRatingModel, MatchRatingId>;
+    countMatchRatings: 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;
+    PlayerTeams: PlayerTeamModel[];
+    getPlayerTeams: Sequelize.HasManyGetAssociationsMixin<PlayerTeamModel>;
+    setPlayerTeams: Sequelize.HasManySetAssociationsMixin<PlayerTeamModel, PlayerTeamId>;
+    addPlayerTeam: Sequelize.HasManyAddAssociationMixin<PlayerTeamModel, PlayerTeamId>;
+    addPlayerTeams: Sequelize.HasManyAddAssociationsMixin<PlayerTeamModel, PlayerTeamId>;
+    createPlayerTeam: Sequelize.HasManyCreateAssociationMixin<PlayerTeamModel>;
+    removePlayerTeam: Sequelize.HasManyRemoveAssociationMixin<PlayerTeamModel, PlayerTeamId>;
+    removePlayerTeams: Sequelize.HasManyRemoveAssociationsMixin<PlayerTeamModel, PlayerTeamId>;
+    hasPlayerTeam: Sequelize.HasManyHasAssociationMixin<PlayerTeamModel, PlayerTeamId>;
+    hasPlayerTeams: Sequelize.HasManyHasAssociationsMixin<PlayerTeamModel, PlayerTeamId>;
+    countPlayerTeams: Sequelize.HasManyCountAssociationsMixin;
+    Rallies: RallyModel[];
+    getRallies: Sequelize.HasManyGetAssociationsMixin<RallyModel>;
+    setRallies: Sequelize.HasManySetAssociationsMixin<RallyModel, RallyId>;
+    addRally: Sequelize.HasManyAddAssociationMixin<RallyModel, RallyId>;
+    addRallies: Sequelize.HasManyAddAssociationsMixin<RallyModel, RallyId>;
+    createRally: Sequelize.HasManyCreateAssociationMixin<RallyModel>;
+    removeRally: Sequelize.HasManyRemoveAssociationMixin<RallyModel, RallyId>;
+    removeRallies: Sequelize.HasManyRemoveAssociationsMixin<RallyModel, RallyId>;
+    hasRally: Sequelize.HasManyHasAssociationMixin<RallyModel, RallyId>;
+    hasRallies: Sequelize.HasManyHasAssociationsMixin<RallyModel, RallyId>;
+    countRallies: Sequelize.HasManyCountAssociationsMixin;
+    static initModel(sequelize: Sequelize.Sequelize): typeof TeamModel;
+}

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

@@ -0,0 +1,63 @@
+import { DataTypes, Model } from 'sequelize';
+import { CountryModel, TacticsModel } from '.';
+export class TeamModel extends Model {
+    static initModel(sequelize) {
+        return TeamModel.init({
+            team_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true
+            },
+            name: {
+                type: DataTypes.STRING,
+                allowNull: false
+            },
+            short_name: {
+                type: DataTypes.STRING,
+                allowNull: false
+            },
+            country_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'Country',
+                    key: 'country_id'
+                }
+            },
+            division_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'Division',
+                    key: 'division_id'
+                }
+            },
+            rating: {
+                type: DataTypes.REAL,
+                allowNull: false,
+                defaultValue: 1000.0
+            },
+            active: {
+                type: DataTypes.BOOLEAN,
+                allowNull: false,
+                defaultValue: true
+            }
+        }, {
+            sequelize,
+            tableName: 'Team',
+            schema: 'public',
+            timestamps: false,
+            defaultScope: {
+                include: [
+                    { model: CountryModel, as: 'country' },
+                    { model: TacticsModel, as: 'tactics' }
+                ]
+            },
+            indexes: [{
+                    name: 'Team_pk',
+                    unique: true,
+                    fields: [{ name: 'team_id' }]
+                }]
+        });
+    }
+}

package/dist/esm/src/data/models/user-currency.d.ts

@@ -0,0 +1,21 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { AuthUserId, AuthUserModel } from '.';
+export interface UserCurrencyAttributes {
+    user_id: string;
+    balance: number;
+    total_earned: number;
+}
+export type UserCurrencyPk = 'user_id';
+export type UserCurrencyId = UserCurrencyModel[UserCurrencyPk];
+export type UserCurrencyCreationAttributes = UserCurrencyAttributes;
+export declare class UserCurrencyModel extends Model<UserCurrencyAttributes, UserCurrencyCreationAttributes> implements UserCurrencyAttributes {
+    user_id: string;
+    balance: number;
+    total_earned: number;
+    user: AuthUserModel;
+    getUser: Sequelize.BelongsToGetAssociationMixin<AuthUserModel>;
+    setUser: Sequelize.BelongsToSetAssociationMixin<AuthUserModel, AuthUserId>;
+    createUser: Sequelize.BelongsToCreateAssociationMixin<AuthUserModel>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof UserCurrencyModel;
+}

package/dist/esm/src/data/models/user-currency.js

@@ -0,0 +1,38 @@
+import { DataTypes, Model } from 'sequelize';
+export class UserCurrencyModel extends Model {
+    static initModel(sequelize) {
+        return UserCurrencyModel.init({
+            user_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'AuthUser',
+                    key: 'user_id'
+                }
+            },
+            balance: {
+                type: DataTypes.INTEGER,
+                allowNull: false,
+                defaultValue: 0
+            },
+            total_earned: {
+                type: DataTypes.INTEGER,
+                allowNull: false,
+                defaultValue: 0
+            }
+        }, {
+            sequelize,
+            tableName: 'UserCurrency',
+            schema: 'public',
+            timestamps: false,
+            indexes: [
+                {
+                    name: 'UserCurrency_pk',
+                    unique: true,
+                    fields: [{ name: 'user_id' }]
+                }
+            ]
+        });
+    }
+}

package/dist/esm/src/data/models/user-player-progress.d.ts

@@ -0,0 +1,19 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { PlayerId, PlayerModel } from '.';
+export interface UserPlayerProgressAttributes {
+    player_id: string;
+    points_played_since_improvement: number;
+}
+export type UserPlayerProgressPk = 'player_id';
+export type UserPlayerProgressId = UserPlayerProgressModel[UserPlayerProgressPk];
+export type UserPlayerProgressCreationAttributes = UserPlayerProgressAttributes;
+export declare class UserPlayerProgressModel extends Model<UserPlayerProgressAttributes, UserPlayerProgressCreationAttributes> implements UserPlayerProgressAttributes {
+    player_id: string;
+    points_played_since_improvement: number;
+    player: PlayerModel;
+    getPlayer: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
+    setPlayer: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;
+    createPlayer: Sequelize.BelongsToCreateAssociationMixin<PlayerModel>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof UserPlayerProgressModel;
+}

package/dist/esm/src/data/models/user-player-progress.js

@@ -0,0 +1,33 @@
+import { DataTypes, Model } from 'sequelize';
+export class UserPlayerProgressModel extends Model {
+    static initModel(sequelize) {
+        return UserPlayerProgressModel.init({
+            player_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'Player',
+                    key: 'player_id'
+                }
+            },
+            points_played_since_improvement: {
+                type: DataTypes.INTEGER,
+                allowNull: false,
+                defaultValue: 0
+            }
+        }, {
+            sequelize,
+            tableName: 'UserPlayerProgress',
+            schema: 'public',
+            timestamps: false,
+            indexes: [
+                {
+                    name: 'UserPlayerProgress_pk',
+                    unique: true,
+                    fields: [{ name: 'player_id' }]
+                }
+            ]
+        });
+    }
+}

package/dist/esm/src/data/models/user-pull-grant.d.ts

@@ -0,0 +1,31 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { AuthUserId, AuthUserModel } from '.';
+export interface UserPullGrantAttributes {
+    grant_id: string;
+    user_id: string;
+    pull_type: string;
+    source_type: string | null;
+    source_id: string | null;
+    granted_at: Date;
+    used_at: Date | null;
+}
+export type UserPullGrantPk = 'grant_id';
+export type UserPullGrantId = UserPullGrantModel[UserPullGrantPk];
+export type UserPullGrantCreationAttributes = Omit<UserPullGrantAttributes, 'granted_at'> & {
+    granted_at?: Date;
+};
+export declare class UserPullGrantModel extends Model<UserPullGrantAttributes, UserPullGrantCreationAttributes> implements UserPullGrantAttributes {
+    grant_id: string;
+    user_id: string;
+    pull_type: string;
+    source_type: string | null;
+    source_id: string | null;
+    granted_at: Date;
+    used_at: Date | null;
+    user: AuthUserModel;
+    getUser: Sequelize.BelongsToGetAssociationMixin<AuthUserModel>;
+    setUser: Sequelize.BelongsToSetAssociationMixin<AuthUserModel, AuthUserId>;
+    createUser: Sequelize.BelongsToCreateAssociationMixin<AuthUserModel>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof UserPullGrantModel;
+}

package/dist/esm/src/data/models/user-pull-grant.js

@@ -0,0 +1,57 @@
+import { DataTypes, Model } from 'sequelize';
+export class UserPullGrantModel extends Model {
+    static initModel(sequelize) {
+        return UserPullGrantModel.init({
+            grant_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true
+            },
+            user_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'AuthUser',
+                    key: 'user_id'
+                }
+            },
+            pull_type: {
+                type: DataTypes.STRING,
+                allowNull: false
+            },
+            source_type: {
+                type: DataTypes.STRING,
+                allowNull: true
+            },
+            source_id: {
+                type: DataTypes.UUID,
+                allowNull: true
+            },
+            granted_at: {
+                type: DataTypes.DATE,
+                allowNull: false,
+                defaultValue: DataTypes.NOW
+            },
+            used_at: {
+                type: DataTypes.DATE,
+                allowNull: true
+            }
+        }, {
+            sequelize,
+            tableName: 'UserPullGrant',
+            schema: 'public',
+            timestamps: false,
+            indexes: [
+                {
+                    name: 'UserPullGrant_pk',
+                    unique: true,
+                    fields: [{ name: 'grant_id' }]
+                },
+                {
+                    name: 'UserPullGrant_user_id_idx',
+                    fields: [{ name: 'user_id' }]
+                }
+            ]
+        });
+    }
+}

package/dist/esm/src/data/models/user-settings.d.ts

@@ -0,0 +1,24 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { AuthUserId, AuthUserModel } from '.';
+export interface AutoDismissRarityConfig {
+    roles: string[];
+    traits: string[];
+}
+export type AutoDismissSettings = Record<string, AutoDismissRarityConfig>;
+export interface UserSettingsAttributes {
+    user_id: string;
+    auto_dismiss: AutoDismissSettings;
+}
+export type UserSettingsPk = 'user_id';
+export type UserSettingsId = UserSettingsModel[UserSettingsPk];
+export type UserSettingsCreationAttributes = UserSettingsAttributes;
+export declare class UserSettingsModel extends Model<UserSettingsAttributes, UserSettingsCreationAttributes> implements UserSettingsAttributes {
+    user_id: string;
+    auto_dismiss: AutoDismissSettings;
+    user: AuthUserModel;
+    getUser: Sequelize.BelongsToGetAssociationMixin<AuthUserModel>;
+    setUser: Sequelize.BelongsToSetAssociationMixin<AuthUserModel, AuthUserId>;
+    createUser: Sequelize.BelongsToCreateAssociationMixin<AuthUserModel>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof UserSettingsModel;
+}

package/dist/esm/src/data/models/user-settings.js

@@ -0,0 +1,33 @@
+import { DataTypes, Model } from 'sequelize';
+export class UserSettingsModel extends Model {
+    static initModel(sequelize) {
+        return UserSettingsModel.init({
+            user_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'AuthUser',
+                    key: 'user_id'
+                }
+            },
+            auto_dismiss: {
+                type: DataTypes.JSONB,
+                allowNull: false,
+                defaultValue: {}
+            }
+        }, {
+            sequelize,
+            tableName: 'UserSettings',
+            schema: 'public',
+            timestamps: false,
+            indexes: [
+                {
+                    name: 'UserSettings_pk',
+                    unique: true,
+                    fields: [{ name: 'user_id' }]
+                }
+            ]
+        });
+    }
+}

package/dist/esm/src/data/models/user-team.d.ts

@@ -0,0 +1,23 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { AuthUserId, AuthUserModel, TeamId, TeamModel } from '.';
+export interface UserTeamAttributes {
+    user_id: string;
+    team_id: string;
+}
+export type UserTeamPk = 'user_id';
+export type UserTeamId = UserTeamModel[UserTeamPk];
+export type UserTeamCreationAttributes = UserTeamAttributes;
+export declare class UserTeamModel extends Model<UserTeamAttributes, UserTeamCreationAttributes> implements UserTeamAttributes {
+    user_id: string;
+    team_id: string;
+    user: AuthUserModel;
+    getUser: Sequelize.BelongsToGetAssociationMixin<AuthUserModel>;
+    setUser: Sequelize.BelongsToSetAssociationMixin<AuthUserModel, AuthUserId>;
+    createUser: Sequelize.BelongsToCreateAssociationMixin<AuthUserModel>;
+    team: TeamModel;
+    getTeam: Sequelize.BelongsToGetAssociationMixin<TeamModel>;
+    setTeam: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>;
+    createTeam: Sequelize.BelongsToCreateAssociationMixin<TeamModel>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof UserTeamModel;
+}

package/dist/esm/src/data/models/user-team.js

@@ -0,0 +1,41 @@
+import { DataTypes, Model } from 'sequelize';
+export class UserTeamModel extends Model {
+    static initModel(sequelize) {
+        return UserTeamModel.init({
+            user_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'AuthUser',
+                    key: 'user_id'
+                }
+            },
+            team_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'Team',
+                    key: 'team_id'
+                }
+            }
+        }, {
+            sequelize,
+            tableName: 'UserTeam',
+            schema: 'public',
+            timestamps: false,
+            indexes: [
+                {
+                    name: 'UserTeam_pk',
+                    unique: true,
+                    fields: [{ name: 'user_id' }]
+                },
+                {
+                    name: 'UserTeam_team_id_uq',
+                    unique: true,
+                    fields: [{ name: 'team_id' }]
+                }
+            ]
+        });
+    }
+}

package/dist/esm/src/data/models/views/box-score-totals.d.ts

@@ -0,0 +1,71 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { PlayerId, PlayerModel } from '..';
+export interface BoxScoreTotalsAttributes {
+    player_id: string;
+    attack_attempts: number;
+    attack_kills: number;
+    attack_errors: number;
+    serve_attempts: number;
+    serve_aces: number;
+    serve_errors: number;
+    reception_attempts: number;
+    reception_perfect: number;
+    reception_positive: number;
+    reception_overpasses: number;
+    reception_errors: number;
+    block_solo: number;
+    block_assists: number;
+    block_errors: number;
+    block_touches: number;
+    setting_assists: number;
+    setting_errors: number;
+    setting_pass: number;
+    defense_digs: number;
+    defense_errors: number;
+    misc_points_played: number;
+    misc_points_won_on_court: number;
+    misc_serve_turns: number;
+    misc_sideout_opportunities: number;
+    misc_successful_sideouts: number;
+    misc_sets_played: number;
+    misc_matches_played: number;
+}
+export type BoxScoreTotalsPk = 'player_id';
+export type BoxScoreTotalsId = BoxScoreTotalsModel[BoxScoreTotalsPk];
+export type BoxScoreTotalsCreationAttributes = BoxScoreTotalsAttributes;
+export declare class BoxScoreTotalsModel extends Model<BoxScoreTotalsAttributes, BoxScoreTotalsCreationAttributes> implements BoxScoreTotalsAttributes {
+    player_id: string;
+    attack_attempts: number;
+    attack_kills: number;
+    attack_errors: number;
+    serve_attempts: number;
+    serve_aces: number;
+    serve_errors: number;
+    reception_attempts: number;
+    reception_perfect: number;
+    reception_positive: number;
+    reception_overpasses: number;
+    reception_errors: number;
+    block_solo: number;
+    block_assists: number;
+    block_errors: number;
+    block_touches: number;
+    setting_assists: number;
+    setting_errors: number;
+    setting_pass: number;
+    defense_digs: number;
+    defense_errors: number;
+    misc_points_played: number;
+    misc_points_won_on_court: number;
+    misc_serve_turns: number;
+    misc_sideout_opportunities: number;
+    misc_successful_sideouts: number;
+    misc_sets_played: number;
+    misc_matches_played: number;
+    Player: PlayerModel;
+    getPlayer: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
+    setPlayer: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;
+    createPlayer: Sequelize.BelongsToCreateAssociationMixin<PlayerModel>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof BoxScoreTotalsModel;
+}