volleyballsimtypes 0.0.359 → 0.0.360

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

@@ -0,0 +1,47 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { DivisionSeasonAttributes, DivisionSeasonId, DivisionSeasonModel, LeagueId, LeagueModel, TeamAttributes, TeamId, TeamModel } from '.';
+export interface DivisionAttributes {
+    division_id: string;
+    league_id: string;
+    tier: number;
+    subdivision: number;
+    DivisionSeasons?: DivisionSeasonAttributes[];
+    Teams?: TeamAttributes[];
+}
+export type DivisionPk = 'division_id';
+export type DivisionId = DivisionModel[DivisionPk];
+export type DivisionCreationAttributes = DivisionAttributes;
+export declare class DivisionModel extends Model<DivisionAttributes, DivisionCreationAttributes> implements DivisionAttributes {
+    division_id: string;
+    league_id: string;
+    tier: number;
+    subdivision: number;
+    league: LeagueModel;
+    getLeague: Sequelize.BelongsToGetAssociationMixin<LeagueModel>;
+    setLeague: Sequelize.BelongsToSetAssociationMixin<LeagueModel, LeagueId>;
+    createLeague: Sequelize.BelongsToCreateAssociationMixin<LeagueModel>;
+    DivisionSeasons: DivisionSeasonModel[];
+    getDivisionSeasons: Sequelize.HasManyGetAssociationsMixin<DivisionSeasonModel>;
+    setDivisionSeasons: Sequelize.HasManySetAssociationsMixin<DivisionSeasonModel, DivisionSeasonId>;
+    addDivisionSeason: Sequelize.HasManyAddAssociationMixin<DivisionSeasonModel, DivisionSeasonId>;
+    addDivisionSeasons: Sequelize.HasManyAddAssociationsMixin<DivisionSeasonModel, DivisionSeasonId>;
+    createDivisionSeason: Sequelize.HasManyCreateAssociationMixin<DivisionSeasonModel>;
+    removeDivisionSeason: Sequelize.HasManyRemoveAssociationMixin<DivisionSeasonModel, DivisionSeasonId>;
+    removeDivisionSeasons: Sequelize.HasManyRemoveAssociationsMixin<DivisionSeasonModel, DivisionSeasonId>;
+    hasDivisionSeason: Sequelize.HasManyHasAssociationMixin<DivisionSeasonModel, DivisionSeasonId>;
+    hasDivisionSeasons: Sequelize.HasManyHasAssociationsMixin<DivisionSeasonModel, DivisionSeasonId>;
+    countDivisionSeasons: Sequelize.HasManyCountAssociationsMixin;
+    Teams: TeamModel[];
+    getTeams: Sequelize.HasManyGetAssociationsMixin<TeamModel>;
+    setTeams: Sequelize.HasManySetAssociationsMixin<TeamModel, TeamId>;
+    addTeam: Sequelize.HasManyAddAssociationMixin<TeamModel, TeamId>;
+    addTeams: Sequelize.HasManyAddAssociationsMixin<TeamModel, TeamId>;
+    createTeam: Sequelize.HasManyCreateAssociationMixin<TeamModel>;
+    removeTeam: Sequelize.HasManyRemoveAssociationMixin<TeamModel, TeamId>;
+    removeTeams: Sequelize.HasManyRemoveAssociationsMixin<TeamModel, TeamId>;
+    hasTeam: Sequelize.HasManyHasAssociationMixin<TeamModel, TeamId>;
+    hasTeams: Sequelize.HasManyHasAssociationsMixin<TeamModel, TeamId>;
+    countTeams: Sequelize.HasManyCountAssociationsMixin;
+    static initModel(sequelize: Sequelize.Sequelize): typeof DivisionModel;
+}

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

@@ -0,0 +1,38 @@
+import { DataTypes, Model } from 'sequelize';
+export class DivisionModel extends Model {
+    static initModel(sequelize) {
+        return DivisionModel.init({
+            division_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true
+            },
+            league_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'League',
+                    key: 'league_id'
+                }
+            },
+            tier: {
+                type: DataTypes.INTEGER,
+                allowNull: false
+            },
+            subdivision: {
+                type: DataTypes.INTEGER,
+                allowNull: false
+            }
+        }, {
+            sequelize,
+            tableName: 'Division',
+            schema: 'public',
+            timestamps: false,
+            indexes: [{
+                    name: 'Division_pk',
+                    unique: true,
+                    fields: [{ name: 'division_id' }]
+                }]
+        });
+    }
+}

package/dist/esm/src/data/models/gacha-pity.d.ts

@@ -0,0 +1,23 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { AuthUserId, AuthUserModel } from '.';
+export interface GachaPityAttributes {
+    user_id: string;
+    legendary_pity: number;
+    mythic_pity: number;
+    special_pity: number;
+}
+export type GachaPityPk = 'user_id';
+export type GachaPityId = GachaPityModel[GachaPityPk];
+export type GachaPityCreationAttributes = GachaPityAttributes;
+export declare class GachaPityModel extends Model<GachaPityAttributes, GachaPityCreationAttributes> implements GachaPityAttributes {
+    user_id: string;
+    legendary_pity: number;
+    mythic_pity: number;
+    special_pity: number;
+    user: AuthUserModel;
+    getUser: Sequelize.BelongsToGetAssociationMixin<AuthUserModel>;
+    setUser: Sequelize.BelongsToSetAssociationMixin<AuthUserModel, AuthUserId>;
+    createUser: Sequelize.BelongsToCreateAssociationMixin<AuthUserModel>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof GachaPityModel;
+}

package/dist/esm/src/data/models/gacha-pity.js

@@ -0,0 +1,43 @@
+import { DataTypes, Model } from 'sequelize';
+export class GachaPityModel extends Model {
+    static initModel(sequelize) {
+        return GachaPityModel.init({
+            user_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'AuthUser',
+                    key: 'user_id'
+                }
+            },
+            legendary_pity: {
+                type: DataTypes.FLOAT,
+                allowNull: false,
+                defaultValue: 0
+            },
+            mythic_pity: {
+                type: DataTypes.FLOAT,
+                allowNull: false,
+                defaultValue: 0
+            },
+            special_pity: {
+                type: DataTypes.FLOAT,
+                allowNull: false,
+                defaultValue: 0
+            }
+        }, {
+            sequelize,
+            tableName: 'GachaPity',
+            schema: 'public',
+            timestamps: false,
+            indexes: [
+                {
+                    name: 'GachaPity_pk',
+                    unique: true,
+                    fields: [{ name: 'user_id' }]
+                }
+            ]
+        });
+    }
+}

package/dist/esm/src/data/models/gacha-pull-history.d.ts

@@ -0,0 +1,31 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { AuthUserId, AuthUserModel, PlayerId, PlayerModel } from '.';
+export interface GachaPullHistoryAttributes {
+    pull_id: string;
+    user_id: string;
+    player_id: string;
+    rarity: string;
+    pull_type: string;
+    pulled_at: Date;
+}
+export type GachaPullHistoryPk = 'pull_id';
+export type GachaPullHistoryId = GachaPullHistoryModel[GachaPullHistoryPk];
+export type GachaPullHistoryCreationAttributes = GachaPullHistoryAttributes;
+export declare class GachaPullHistoryModel extends Model<GachaPullHistoryAttributes, GachaPullHistoryCreationAttributes> implements GachaPullHistoryAttributes {
+    pull_id: string;
+    user_id: string;
+    player_id: string;
+    rarity: string;
+    pull_type: string;
+    pulled_at: Date;
+    user: AuthUserModel;
+    getUser: Sequelize.BelongsToGetAssociationMixin<AuthUserModel>;
+    setUser: Sequelize.BelongsToSetAssociationMixin<AuthUserModel, AuthUserId>;
+    createUser: Sequelize.BelongsToCreateAssociationMixin<AuthUserModel>;
+    player: PlayerModel;
+    getPlayer: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
+    setPlayer: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;
+    createPlayer: Sequelize.BelongsToCreateAssociationMixin<PlayerModel>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof GachaPullHistoryModel;
+}

package/dist/esm/src/data/models/gacha-pull-history.js

@@ -0,0 +1,57 @@
+import { DataTypes, Model } from 'sequelize';
+export class GachaPullHistoryModel extends Model {
+    static initModel(sequelize) {
+        return GachaPullHistoryModel.init({
+            pull_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true
+            },
+            user_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'AuthUser',
+                    key: 'user_id'
+                }
+            },
+            player_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'Player',
+                    key: 'player_id'
+                }
+            },
+            rarity: {
+                type: DataTypes.STRING,
+                allowNull: false
+            },
+            pull_type: {
+                type: DataTypes.STRING,
+                allowNull: false
+            },
+            pulled_at: {
+                type: DataTypes.DATE,
+                allowNull: false,
+                defaultValue: DataTypes.NOW
+            }
+        }, {
+            sequelize,
+            tableName: 'GachaPullHistory',
+            schema: 'public',
+            timestamps: false,
+            indexes: [
+                {
+                    name: 'GachaPullHistory_pk',
+                    unique: true,
+                    fields: [{ name: 'pull_id' }]
+                },
+                {
+                    name: 'GachaPullHistory_user_id_idx',
+                    fields: [{ name: 'user_id' }]
+                }
+            ]
+        });
+    }
+}

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

@@ -0,0 +1,43 @@
+export * from './box-score';
+export * from './auth-identity';
+export * from './auth-session';
+export * from './auth-user';
+export * from './user-team';
+export * from './competition';
+export * from './competition-mvp';
+export * from './competition-champion';
+export * from './competition-match';
+export * from './competition-standings';
+export * from './competition-standings-match';
+export * from './competition-teams';
+export * from './country';
+export * from './iteration';
+export * from './league';
+export * from './division';
+export * from './division-season';
+export * from './match';
+export * from './match-rating';
+export * from './match-result';
+export * from './match-set';
+export * from './performance-stats';
+export * from './player';
+export * from './player-improvement-log';
+export * from './player-team';
+export * from './rally';
+export * from './promotion-match';
+export * from './region-qualifier';
+export * from './coach';
+export * from './team';
+export * from './team-replacement';
+export * from './tactics';
+export * from './user-currency';
+export * from './user-player-progress';
+export * from './gacha-pity';
+export * from './gacha-pull-history';
+export * from './wishlist';
+export * from './currency-transaction';
+export * from './user-pull-grant';
+export * from './user-settings';
+export * from './notification';
+export * from './vper';
+export * from './views';

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

@@ -0,0 +1,43 @@
+export * from './box-score';
+export * from './auth-identity';
+export * from './auth-session';
+export * from './auth-user';
+export * from './user-team';
+export * from './competition';
+export * from './competition-mvp';
+export * from './competition-champion';
+export * from './competition-match';
+export * from './competition-standings';
+export * from './competition-standings-match';
+export * from './competition-teams';
+export * from './country';
+export * from './iteration';
+export * from './league';
+export * from './division';
+export * from './division-season';
+export * from './match';
+export * from './match-rating';
+export * from './match-result';
+export * from './match-set';
+export * from './performance-stats';
+export * from './player';
+export * from './player-improvement-log';
+export * from './player-team';
+export * from './rally';
+export * from './promotion-match';
+export * from './region-qualifier';
+export * from './coach';
+export * from './team';
+export * from './team-replacement';
+export * from './tactics';
+export * from './user-currency';
+export * from './user-player-progress';
+export * from './gacha-pity';
+export * from './gacha-pull-history';
+export * from './wishlist';
+export * from './currency-transaction';
+export * from './user-pull-grant';
+export * from './user-settings';
+export * from './notification';
+export * from './vper';
+export * from './views';

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

@@ -0,0 +1,26 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { CompetitionId, CompetitionModel } from '.';
+export interface IterationAttributes {
+    iteration_id: number;
+    start_date: Date;
+}
+export type IterationPk = 'iteration_id';
+export type IterationId = IterationModel[IterationPk];
+export type IterationCreationAttributes = IterationAttributes;
+export declare class IterationModel extends Model<IterationAttributes, IterationCreationAttributes> implements IterationAttributes {
+    iteration_id: number;
+    start_date: Date;
+    Competitions: CompetitionModel[];
+    getCompetitions: Sequelize.HasManyGetAssociationsMixin<CompetitionModel>;
+    setCompetitions: Sequelize.HasManySetAssociationsMixin<CompetitionModel, CompetitionId>;
+    addCompetition: Sequelize.HasManyAddAssociationMixin<CompetitionModel, CompetitionId>;
+    addCompetitions: Sequelize.HasManyAddAssociationsMixin<CompetitionModel, CompetitionId>;
+    createCompetition: Sequelize.HasManyCreateAssociationMixin<CompetitionModel>;
+    removeCompetition: Sequelize.HasManyRemoveAssociationMixin<CompetitionModel, CompetitionId>;
+    removeCompetitions: Sequelize.HasManyRemoveAssociationsMixin<CompetitionModel, CompetitionId>;
+    hasCompetition: Sequelize.HasManyHasAssociationMixin<CompetitionModel, CompetitionId>;
+    hasCompetitions: Sequelize.HasManyHasAssociationsMixin<CompetitionModel, CompetitionId>;
+    countCompetitions: Sequelize.HasManyCountAssociationsMixin;
+    static initModel(sequelize: Sequelize.Sequelize): typeof IterationModel;
+}

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

@@ -0,0 +1,26 @@
+import { DataTypes, Model } from 'sequelize';
+export class IterationModel extends Model {
+    static initModel(sequelize) {
+        return IterationModel.init({
+            iteration_id: {
+                type: DataTypes.INTEGER,
+                allowNull: false,
+                primaryKey: true
+            },
+            start_date: {
+                type: DataTypes.DATEONLY,
+                allowNull: false
+            }
+        }, {
+            sequelize,
+            tableName: 'Iteration',
+            schema: 'public',
+            timestamps: false,
+            indexes: [{
+                    name: 'Iteration_pk',
+                    unique: true,
+                    fields: [{ name: 'iteration_id' }]
+                }]
+        });
+    }
+}

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

@@ -0,0 +1,33 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { CountryId, CountryModel, DivisionAttributes, DivisionId, DivisionModel } from '.';
+export interface LeagueAttributes {
+    league_id: string;
+    country_id: string;
+    name: string;
+    Divisions?: DivisionAttributes[];
+}
+export type LeaguePk = 'league_id';
+export type LeagueId = LeagueModel[LeaguePk];
+export type LeagueCreationAttributes = LeagueAttributes;
+export declare class LeagueModel extends Model<LeagueAttributes, LeagueCreationAttributes> implements LeagueAttributes {
+    league_id: string;
+    country_id: string;
+    name: string;
+    country: CountryModel;
+    getCountry: Sequelize.BelongsToGetAssociationMixin<CountryModel>;
+    setCountry: Sequelize.BelongsToSetAssociationMixin<CountryModel, CountryId>;
+    createCountry: Sequelize.BelongsToCreateAssociationMixin<CountryModel>;
+    Divisions: DivisionModel[];
+    getDivisions: Sequelize.HasManyGetAssociationsMixin<DivisionModel>;
+    setDivisions: Sequelize.HasManySetAssociationsMixin<DivisionModel, DivisionId>;
+    addDivision: Sequelize.HasManyAddAssociationMixin<DivisionModel, DivisionId>;
+    addDivisions: Sequelize.HasManyAddAssociationsMixin<DivisionModel, DivisionId>;
+    createDivision: Sequelize.HasManyCreateAssociationMixin<DivisionModel>;
+    removeDivision: Sequelize.HasManyRemoveAssociationMixin<DivisionModel, DivisionId>;
+    removeDivisions: Sequelize.HasManyRemoveAssociationsMixin<DivisionModel, DivisionId>;
+    hasDivision: Sequelize.HasManyHasAssociationMixin<DivisionModel, DivisionId>;
+    hasDivisions: Sequelize.HasManyHasAssociationsMixin<DivisionModel, DivisionId>;
+    countDivisions: Sequelize.HasManyCountAssociationsMixin;
+    static initModel(sequelize: Sequelize.Sequelize): typeof LeagueModel;
+}

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

@@ -0,0 +1,40 @@
+import { DataTypes, Model } from 'sequelize';
+import { CountryModel } from '.';
+export class LeagueModel extends Model {
+    static initModel(sequelize) {
+        return LeagueModel.init({
+            league_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true
+            },
+            country_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'Country',
+                    key: 'country_id'
+                }
+            },
+            name: {
+                type: DataTypes.STRING,
+                allowNull: false
+            }
+        }, {
+            sequelize,
+            tableName: 'League',
+            schema: 'public',
+            timestamps: false,
+            defaultScope: {
+                include: [
+                    { model: CountryModel, as: 'country' }
+                ]
+            },
+            indexes: [{
+                    name: 'League_pk',
+                    unique: true,
+                    fields: [{ name: 'league_id' }]
+                }]
+        });
+    }
+}

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

@@ -0,0 +1,27 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { MatchId, MatchModel, TeamId, TeamModel } from '.';
+export interface MatchRatingAttributes {
+    match_id: string;
+    team_id: string;
+    p: number;
+    dR: number;
+}
+export type MatchRatingPk = 'match_id' | 'team_id';
+export type MatchRatingId = MatchRatingModel[MatchRatingPk];
+export type MatchRatingCreationAttributes = MatchRatingAttributes;
+export declare class MatchRatingModel extends Model<MatchRatingAttributes, MatchRatingCreationAttributes> implements MatchRatingAttributes {
+    match_id: string;
+    team_id: string;
+    p: number;
+    dR: number;
+    match: MatchModel;
+    getMatch: Sequelize.BelongsToGetAssociationMixin<MatchModel>;
+    setMatch: Sequelize.BelongsToSetAssociationMixin<MatchModel, MatchId>;
+    createMatch: Sequelize.BelongsToCreateAssociationMixin<MatchModel>;
+    team: TeamModel;
+    getTeam: Sequelize.BelongsToGetAssociationMixin<TeamModel>;
+    setTeam: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>;
+    createTeam: Sequelize.BelongsToCreateAssociationMixin<TeamModel>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof MatchRatingModel;
+}

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

@@ -0,0 +1,48 @@
+import { DataTypes, Model } from 'sequelize';
+export class MatchRatingModel extends Model {
+    static initModel(sequelize) {
+        return MatchRatingModel.init({
+            match_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'Match',
+                    key: 'match_id'
+                }
+            },
+            team_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'Team',
+                    key: 'team_id'
+                }
+            },
+            p: {
+                type: DataTypes.REAL,
+                allowNull: false,
+                comment: 'Probability of winning'
+            },
+            dR: {
+                type: DataTypes.REAL,
+                allowNull: false,
+                comment: 'variance on rating: K * (S - p)'
+            }
+        }, {
+            sequelize,
+            tableName: 'MatchRating',
+            schema: 'public',
+            timestamps: false,
+            indexes: [{
+                    name: 'MatchRating_pk',
+                    unique: true,
+                    fields: [
+                        { name: 'match_id' },
+                        { name: 'team_id' }
+                    ]
+                }]
+        });
+    }
+}

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

@@ -0,0 +1,27 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { MatchId, MatchModel, TeamId, TeamModel } from '.';
+export interface MatchResultAttributes {
+    match_id: string;
+    home_scores: number[];
+    away_scores: number[];
+    winner_team_id: string | null;
+}
+export type MatchResultPk = 'match_id';
+export type MatchResultId = MatchResultModel[MatchResultPk];
+export type MatchResultCreationAttributes = MatchResultAttributes;
+export declare class MatchResultModel extends Model<MatchResultAttributes, MatchResultCreationAttributes> implements MatchResultAttributes {
+    match_id: string;
+    home_scores: number[];
+    away_scores: number[];
+    winner_team_id: string | null;
+    Match: MatchModel;
+    getMatch: Sequelize.BelongsToGetAssociationMixin<MatchModel>;
+    setMatch: Sequelize.BelongsToSetAssociationMixin<MatchModel, MatchId>;
+    createMatch: Sequelize.BelongsToCreateAssociationMixin<MatchModel>;
+    Winner: TeamModel;
+    getWinner: Sequelize.BelongsToGetAssociationMixin<TeamModel>;
+    setWinner: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>;
+    createWinner: Sequelize.BelongsToCreateAssociationMixin<TeamModel>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof MatchResultModel;
+}

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

@@ -0,0 +1,34 @@
+import { DataTypes, Model } from 'sequelize';
+export class MatchResultModel extends Model {
+    static initModel(sequelize) {
+        return MatchResultModel.init({
+            match_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true
+            },
+            home_scores: {
+                type: DataTypes.ARRAY(DataTypes.INTEGER),
+                allowNull: false
+            },
+            away_scores: {
+                type: DataTypes.ARRAY(DataTypes.INTEGER),
+                allowNull: false
+            },
+            winner_team_id: {
+                type: DataTypes.UUID,
+                allowNull: true
+            }
+        }, {
+            sequelize,
+            tableName: 'MatchResult',
+            schema: 'public',
+            timestamps: false,
+            indexes: [{
+                    name: 'MatchResult_pk',
+                    unique: true,
+                    fields: [{ name: 'match_id' }]
+                }]
+        });
+    }
+}

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

@@ -0,0 +1,65 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { BoxScoreAttributes, BoxScoreId, BoxScoreModel, MatchId, MatchModel, PlayerId, PlayerModel, RallyAttributes, RallyId, RallyModel } from '.';
+import { PlayerPositionAttributes } from '../transformers';
+export interface MatchSetAttributes {
+    match_set_id: string;
+    match_id: string;
+    is_tie_break: boolean;
+    order: number;
+    home_score: number;
+    away_score: number;
+    player_positions: PlayerPositionAttributes[];
+    Rallies?: RallyAttributes[];
+    BoxScores?: BoxScoreAttributes[];
+}
+export type MatchSetPk = 'match_set_id';
+export type MatchSetId = MatchSetModel[MatchSetPk];
+export type MatchSetCreationAttributes = MatchSetAttributes;
+export declare class MatchSetModel extends Model<MatchSetAttributes, MatchSetCreationAttributes> implements MatchSetAttributes {
+    match_set_id: string;
+    match_id: string;
+    is_tie_break: boolean;
+    order: number;
+    home_score: number;
+    away_score: number;
+    player_positions: PlayerPositionAttributes[];
+    match: MatchModel;
+    getMatch: Sequelize.BelongsToGetAssociationMixin<MatchModel>;
+    setMatch: Sequelize.BelongsToSetAssociationMixin<MatchModel, MatchId>;
+    createMatch: Sequelize.BelongsToCreateAssociationMixin<MatchModel>;
+    BoxScores: BoxScoreModel[];
+    getBoxScores: Sequelize.HasManyGetAssociationsMixin<BoxScoreModel>;
+    setBoxScores: Sequelize.HasManySetAssociationsMixin<BoxScoreModel, BoxScoreId>;
+    addBoxScore: Sequelize.HasManyAddAssociationMixin<BoxScoreModel, BoxScoreId>;
+    addBoxScores: Sequelize.HasManyAddAssociationsMixin<BoxScoreModel, BoxScoreId>;
+    createBoxScore: Sequelize.HasManyCreateAssociationMixin<BoxScoreModel>;
+    removeBoxScore: Sequelize.HasManyRemoveAssociationMixin<BoxScoreModel, BoxScoreId>;
+    removeBoxScores: Sequelize.HasManyRemoveAssociationsMixin<BoxScoreModel, BoxScoreId>;
+    hasBoxScore: Sequelize.HasManyHasAssociationMixin<BoxScoreModel, BoxScoreId>;
+    hasBoxScores: Sequelize.HasManyHasAssociationsMixin<BoxScoreModel, BoxScoreId>;
+    countBoxScores: Sequelize.HasManyCountAssociationsMixin;
+    SetStatsPlayers: PlayerModel[];
+    getSetStatsPlayers: Sequelize.BelongsToManyGetAssociationsMixin<PlayerModel>;
+    setSetStatsPlayers: Sequelize.BelongsToManySetAssociationsMixin<PlayerModel, PlayerId>;
+    addSetStatsPlayer: Sequelize.BelongsToManyAddAssociationMixin<PlayerModel, PlayerId>;
+    addSetStatsPlayers: Sequelize.BelongsToManyAddAssociationsMixin<PlayerModel, PlayerId>;
+    createSetStatsPlayer: Sequelize.BelongsToManyCreateAssociationMixin<PlayerModel>;
+    removeSetStatsPlayer: Sequelize.BelongsToManyRemoveAssociationMixin<PlayerModel, PlayerId>;
+    removeSetStatsPlayers: Sequelize.BelongsToManyRemoveAssociationsMixin<PlayerModel, PlayerId>;
+    hasSetStatsPlayer: Sequelize.BelongsToManyHasAssociationMixin<PlayerModel, PlayerId>;
+    hasSetStatsPlayers: Sequelize.BelongsToManyHasAssociationsMixin<PlayerModel, PlayerId>;
+    countSetStatsPlayers: Sequelize.BelongsToManyCountAssociationsMixin;
+    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 MatchSetModel;
+}