volleyballsimtypes 0.0.8 → 0.0.9

package/dist/cjs/src/data/models/match-set-stats.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MatchSetStatsModel = void 0;
+const sequelize_1 = require("sequelize");
+class MatchSetStatsModel extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return MatchSetStatsModel.init({
+            player_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'Player',
+                    key: 'player_id'
+                }
+            },
+            match_set_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'MatchSet',
+                    key: 'match_set_id'
+                }
+            },
+            aces: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false,
+                defaultValue: 0
+            },
+            attempts: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false,
+                defaultValue: 0
+            },
+            contacts: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false,
+                defaultValue: 0
+            },
+            rallies_played: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false,
+                defaultValue: 0
+            },
+            serve_success: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false,
+                defaultValue: 0
+            },
+            serve_error: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false,
+                defaultValue: 0
+            },
+            reception_success: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false,
+                defaultValue: 0
+            },
+            reception_error: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false,
+                defaultValue: 0
+            },
+            set_success: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false,
+                defaultValue: 0
+            },
+            set_error: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false,
+                defaultValue: 0
+            },
+            attack_success: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false,
+                defaultValue: 0
+            },
+            attack_error: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false,
+                defaultValue: 0
+            },
+            block_success: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false,
+                defaultValue: 0
+            },
+            block_error: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false,
+                defaultValue: 0
+            },
+            kills: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false,
+                defaultValue: 0
+            },
+            kill_blocks: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false,
+                defaultValue: 0
+            },
+            assists: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false,
+                defaultValue: 0
+            }
+        }, {
+            sequelize,
+            tableName: 'MatchSetStats',
+            schema: 'public',
+            timestamps: false,
+            indexes: [
+                {
+                    name: 'MatchSetStats_pk',
+                    unique: true,
+                    fields: [
+                        { name: 'player_id' },
+                        { name: 'match_set_id' }
+                    ]
+                }
+            ]
+        });
+    }
+}
+exports.MatchSetStatsModel = MatchSetStatsModel;

package/dist/cjs/src/data/models/match-set.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MatchSetModel = void 0;
+const sequelize_1 = require("sequelize");
+class MatchSetModel extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return MatchSetModel.init({
+            match_set_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true
+            },
+            match_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'Match',
+                    key: 'match_id'
+                }
+            },
+            is_tie_break: {
+                type: sequelize_1.DataTypes.BOOLEAN,
+                allowNull: false,
+                defaultValue: false
+            },
+            home_libero: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: true,
+                references: {
+                    model: 'Player',
+                    key: 'player_id'
+                }
+            },
+            away_libero: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: true,
+                references: {
+                    model: 'Player',
+                    key: 'player_id'
+                }
+            },
+            order: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false
+            },
+            home_score: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false
+            },
+            away_score: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false
+            }
+        }, {
+            sequelize,
+            tableName: 'MatchSet',
+            schema: 'public',
+            timestamps: false,
+            indexes: [
+                {
+                    name: 'MatchSet_pk',
+                    unique: true,
+                    fields: [
+                        { name: 'match_set_id' }
+                    ]
+                }
+            ]
+        });
+    }
+}
+exports.MatchSetModel = MatchSetModel;

package/dist/cjs/src/data/models/match.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MatchModel = void 0;
+const sequelize_1 = require("sequelize");
+class MatchModel extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return MatchModel.init({
+            match_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true
+            },
+            home_team: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'Team',
+                    key: 'team_id'
+                }
+            },
+            away_team: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'Team',
+                    key: 'team_id'
+                }
+            },
+            scheduled_date: {
+                type: sequelize_1.DataTypes.DATEONLY,
+                allowNull: false
+            },
+            season_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'Season',
+                    key: 'season_id'
+                }
+            }
+        }, {
+            sequelize,
+            tableName: 'Match',
+            schema: 'public',
+            timestamps: false,
+            indexes: [
+                {
+                    name: 'Match_pk',
+                    unique: true,
+                    fields: [
+                        { name: 'match_id' }
+                    ]
+                }
+            ]
+        });
+    }
+}
+exports.MatchModel = MatchModel;

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

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PerformanceStatsModel = void 0;
+const sequelize_1 = require("sequelize");
+class PerformanceStatsModel extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return PerformanceStatsModel.init({
+            player_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'Player',
+                    key: 'player_id'
+                }
+            },
+            setting: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false,
+                defaultValue: 0
+            },
+            pass: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false,
+                defaultValue: 0
+            },
+            reception: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false,
+                defaultValue: 0
+            },
+            spike: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false,
+                defaultValue: 0
+            },
+            back_attack: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false,
+                defaultValue: 0
+            },
+            jump: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false,
+                defaultValue: 0
+            },
+            block: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false
+            },
+            awareness: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false,
+                defaultValue: 0
+            },
+            serve: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false,
+                defaultValue: 0
+            },
+            stamina: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false,
+                defaultValue: 0
+            },
+            defense: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false,
+                defaultValue: 0
+            }
+        }, {
+            sequelize,
+            tableName: 'PerformanceStats',
+            schema: 'public',
+            timestamps: false,
+            indexes: [
+                {
+                    name: 'PerformanceStats_pk',
+                    unique: true,
+                    fields: [
+                        { name: 'player_id' }
+                    ]
+                }
+            ]
+        });
+    }
+}
+exports.PerformanceStatsModel = PerformanceStatsModel;

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

@@ -0,0 +1,278 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import type { BlockId, BlockModel } from './block';
+import type { CountryId, CountryModel } from './country';
+import type { EventId, EventModel } from './event';
+import type { LiberoReplacementId, LiberoReplacementModel } from './libero-replacement';
+import type { MatchSetId, MatchSetModel } from './match-set';
+import type { MatchSetStatsAttributes, MatchSetStatsId, MatchSetStatsModel } from './match-set-stats';
+import type { PerformanceStatsAttributes, PerformanceStatsId, PerformanceStatsModel } from './performance-stats';
+import type { RallyId, RallyModel } from './rally';
+import type { RallyPositionId, RallyPositionModel } from './rally-position';
+import type { ReceptionId, ReceptionModel } from './reception';
+import type { ScoreId, ScoreModel } from './score';
+import type { ServeId, ServeModel } from './serve';
+import type { SetId, SetModel } from './set';
+import type { SpikeId, SpikeModel } from './spike';
+import type { SubstitutionId, SubstitutionModel } from './substitution';
+import type { TeamId, TeamModel } from './team';
+export interface PlayerAttributes {
+    player_id: string;
+    jersey_number: number;
+    roles: RoleType[];
+    first_name: string;
+    last_name: string;
+    country_id: string;
+    team_id: string;
+    traits: TraitType[];
+    PerformanceStat?: PerformanceStatsAttributes;
+    MatchSetStats?: MatchSetStatsAttributes[];
+}
+export type RoleType = 'SETTER' | 'LIBERO' | 'OUTSIDE_HITTER' | 'OPPOSITE_HITTER' | 'MIDDLE_BLOCKER' | 'DEFENSIVE_SPECIALIST';
+export type TraitType = 'MARKSMAN' | 'MOVING_WALL' | 'MASTER_MIND' | 'METEOR_SERVE' | 'VIGOROUS' | 'GUARDIAN';
+export type PlayerPk = 'player_id';
+export type PlayerId = PlayerModel[PlayerPk];
+export type PlayerCreationAttributes = PlayerAttributes;
+export declare class PlayerModel extends Model<PlayerAttributes, PlayerCreationAttributes> implements PlayerAttributes {
+    player_id: string;
+    jersey_number: number;
+    roles: RoleType[];
+    first_name: string;
+    last_name: string;
+    country_id: string;
+    team_id: string;
+    traits: TraitType[];
+    country: CountryModel;
+    getCountry: Sequelize.BelongsToGetAssociationMixin<CountryModel>;
+    setCountry: Sequelize.BelongsToSetAssociationMixin<CountryModel, CountryId>;
+    createCountry: Sequelize.BelongsToCreateAssociationMixin<CountryModel>;
+    Blocks: BlockModel[];
+    getBlocks: Sequelize.HasManyGetAssociationsMixin<BlockModel>;
+    setBlocks: Sequelize.HasManySetAssociationsMixin<BlockModel, BlockId>;
+    addBlock: Sequelize.HasManyAddAssociationMixin<BlockModel, BlockId>;
+    addBlocks: Sequelize.HasManyAddAssociationsMixin<BlockModel, BlockId>;
+    createBlock: Sequelize.HasManyCreateAssociationMixin<BlockModel>;
+    removeBlock: Sequelize.HasManyRemoveAssociationMixin<BlockModel, BlockId>;
+    removeBlocks: Sequelize.HasManyRemoveAssociationsMixin<BlockModel, BlockId>;
+    hasBlock: Sequelize.HasManyHasAssociationMixin<BlockModel, BlockId>;
+    hasBlocks: Sequelize.HasManyHasAssociationsMixin<BlockModel, BlockId>;
+    countBlocks: Sequelize.HasManyCountAssociationsMixin;
+    blocker_1_Blocks: BlockModel[];
+    getBlocker_1_Blocks: Sequelize.HasManyGetAssociationsMixin<BlockModel>;
+    setBlocker_1_Blocks: Sequelize.HasManySetAssociationsMixin<BlockModel, BlockId>;
+    addBlocker_1_Block: Sequelize.HasManyAddAssociationMixin<BlockModel, BlockId>;
+    addBlocker_1_Blocks: Sequelize.HasManyAddAssociationsMixin<BlockModel, BlockId>;
+    createBlocker_1_Block: Sequelize.HasManyCreateAssociationMixin<BlockModel>;
+    removeBlocker_1_Block: Sequelize.HasManyRemoveAssociationMixin<BlockModel, BlockId>;
+    removeBlocker_1_Blocks: Sequelize.HasManyRemoveAssociationsMixin<BlockModel, BlockId>;
+    hasBlocker_1_Block: Sequelize.HasManyHasAssociationMixin<BlockModel, BlockId>;
+    hasBlocker_1_Blocks: Sequelize.HasManyHasAssociationsMixin<BlockModel, BlockId>;
+    countBlocker_1_Blocks: Sequelize.HasManyCountAssociationsMixin;
+    blocker_2_Blocks: BlockModel[];
+    getBlocker_2_Blocks: Sequelize.HasManyGetAssociationsMixin<BlockModel>;
+    setBlocker_2_Blocks: Sequelize.HasManySetAssociationsMixin<BlockModel, BlockId>;
+    addBlocker_2_Block: Sequelize.HasManyAddAssociationMixin<BlockModel, BlockId>;
+    addBlocker_2_Blocks: Sequelize.HasManyAddAssociationsMixin<BlockModel, BlockId>;
+    createBlocker_2_Block: Sequelize.HasManyCreateAssociationMixin<BlockModel>;
+    removeBlocker_2_Block: Sequelize.HasManyRemoveAssociationMixin<BlockModel, BlockId>;
+    removeBlocker_2_Blocks: Sequelize.HasManyRemoveAssociationsMixin<BlockModel, BlockId>;
+    hasBlocker_2_Block: Sequelize.HasManyHasAssociationMixin<BlockModel, BlockId>;
+    hasBlocker_2_Blocks: Sequelize.HasManyHasAssociationsMixin<BlockModel, BlockId>;
+    countBlocker_2_Blocks: Sequelize.HasManyCountAssociationsMixin;
+    blocker_3_Blocks: BlockModel[];
+    getBlocker_3_Blocks: Sequelize.HasManyGetAssociationsMixin<BlockModel>;
+    setBlocker_3_Blocks: Sequelize.HasManySetAssociationsMixin<BlockModel, BlockId>;
+    addBlocker_3_Block: Sequelize.HasManyAddAssociationMixin<BlockModel, BlockId>;
+    addBlocker_3_Blocks: Sequelize.HasManyAddAssociationsMixin<BlockModel, BlockId>;
+    createBlocker_3_Block: Sequelize.HasManyCreateAssociationMixin<BlockModel>;
+    removeBlocker_3_Block: Sequelize.HasManyRemoveAssociationMixin<BlockModel, BlockId>;
+    removeBlocker_3_Blocks: Sequelize.HasManyRemoveAssociationsMixin<BlockModel, BlockId>;
+    hasBlocker_3_Block: Sequelize.HasManyHasAssociationMixin<BlockModel, BlockId>;
+    hasBlocker_3_Blocks: Sequelize.HasManyHasAssociationsMixin<BlockModel, BlockId>;
+    countBlocker_3_Blocks: Sequelize.HasManyCountAssociationsMixin;
+    Events: EventModel[];
+    getEvents: Sequelize.HasManyGetAssociationsMixin<EventModel>;
+    setEvents: Sequelize.HasManySetAssociationsMixin<EventModel, EventId>;
+    addEvent: Sequelize.HasManyAddAssociationMixin<EventModel, EventId>;
+    addEvents: Sequelize.HasManyAddAssociationsMixin<EventModel, EventId>;
+    createEvent: Sequelize.HasManyCreateAssociationMixin<EventModel>;
+    removeEvent: Sequelize.HasManyRemoveAssociationMixin<EventModel, EventId>;
+    removeEvents: Sequelize.HasManyRemoveAssociationsMixin<EventModel, EventId>;
+    hasEvent: Sequelize.HasManyHasAssociationMixin<EventModel, EventId>;
+    hasEvents: Sequelize.HasManyHasAssociationsMixin<EventModel, EventId>;
+    countEvents: Sequelize.HasManyCountAssociationsMixin;
+    LiberoReplacements: LiberoReplacementModel[];
+    getLiberoReplacements: Sequelize.HasManyGetAssociationsMixin<LiberoReplacementModel>;
+    setLiberoReplacements: Sequelize.HasManySetAssociationsMixin<LiberoReplacementModel, LiberoReplacementId>;
+    addLiberoReplacement: Sequelize.HasManyAddAssociationMixin<LiberoReplacementModel, LiberoReplacementId>;
+    addLiberoReplacements: Sequelize.HasManyAddAssociationsMixin<LiberoReplacementModel, LiberoReplacementId>;
+    createLiberoReplacement: Sequelize.HasManyCreateAssociationMixin<LiberoReplacementModel>;
+    removeLiberoReplacement: Sequelize.HasManyRemoveAssociationMixin<LiberoReplacementModel, LiberoReplacementId>;
+    removeLiberoReplacements: Sequelize.HasManyRemoveAssociationsMixin<LiberoReplacementModel, LiberoReplacementId>;
+    hasLiberoReplacement: Sequelize.HasManyHasAssociationMixin<LiberoReplacementModel, LiberoReplacementId>;
+    hasLiberoReplacements: Sequelize.HasManyHasAssociationsMixin<LiberoReplacementModel, LiberoReplacementId>;
+    countLiberoReplacements: Sequelize.HasManyCountAssociationsMixin;
+    player_LiberoReplacements: LiberoReplacementModel[];
+    getPlayer_LiberoReplacements: Sequelize.HasManyGetAssociationsMixin<LiberoReplacementModel>;
+    setPlayer_LiberoReplacements: Sequelize.HasManySetAssociationsMixin<LiberoReplacementModel, LiberoReplacementId>;
+    addPlayer_LiberoReplacement: Sequelize.HasManyAddAssociationMixin<LiberoReplacementModel, LiberoReplacementId>;
+    addPlayer_LiberoReplacements: Sequelize.HasManyAddAssociationsMixin<LiberoReplacementModel, LiberoReplacementId>;
+    createPlayer_LiberoReplacement: Sequelize.HasManyCreateAssociationMixin<LiberoReplacementModel>;
+    removePlayer_LiberoReplacement: Sequelize.HasManyRemoveAssociationMixin<LiberoReplacementModel, LiberoReplacementId>;
+    removePlayer_LiberoReplacements: Sequelize.HasManyRemoveAssociationsMixin<LiberoReplacementModel, LiberoReplacementId>;
+    hasPlayer_LiberoReplacement: Sequelize.HasManyHasAssociationMixin<LiberoReplacementModel, LiberoReplacementId>;
+    hasPlayer_LiberoReplacements: Sequelize.HasManyHasAssociationsMixin<LiberoReplacementModel, LiberoReplacementId>;
+    countPlayer_LiberoReplacements: Sequelize.HasManyCountAssociationsMixin;
+    MatchSets: MatchSetModel[];
+    getMatchSets: Sequelize.HasManyGetAssociationsMixin<MatchSetModel>;
+    setMatchSets: Sequelize.HasManySetAssociationsMixin<MatchSetModel, MatchSetId>;
+    addMatchSet: Sequelize.HasManyAddAssociationMixin<MatchSetModel, MatchSetId>;
+    addMatchSets: Sequelize.HasManyAddAssociationsMixin<MatchSetModel, MatchSetId>;
+    createMatchSet: Sequelize.HasManyCreateAssociationMixin<MatchSetModel>;
+    removeMatchSet: Sequelize.HasManyRemoveAssociationMixin<MatchSetModel, MatchSetId>;
+    removeMatchSets: Sequelize.HasManyRemoveAssociationsMixin<MatchSetModel, MatchSetId>;
+    hasMatchSet: Sequelize.HasManyHasAssociationMixin<MatchSetModel, MatchSetId>;
+    hasMatchSets: Sequelize.HasManyHasAssociationsMixin<MatchSetModel, MatchSetId>;
+    countMatchSets: Sequelize.HasManyCountAssociationsMixin;
+    home_libero_MatchSets: MatchSetModel[];
+    getHome_libero_MatchSets: Sequelize.HasManyGetAssociationsMixin<MatchSetModel>;
+    setHome_libero_MatchSets: Sequelize.HasManySetAssociationsMixin<MatchSetModel, MatchSetId>;
+    addHome_libero_MatchSet: Sequelize.HasManyAddAssociationMixin<MatchSetModel, MatchSetId>;
+    addHome_libero_MatchSets: Sequelize.HasManyAddAssociationsMixin<MatchSetModel, MatchSetId>;
+    createHome_libero_MatchSet: Sequelize.HasManyCreateAssociationMixin<MatchSetModel>;
+    removeHome_libero_MatchSet: Sequelize.HasManyRemoveAssociationMixin<MatchSetModel, MatchSetId>;
+    removeHome_libero_MatchSets: Sequelize.HasManyRemoveAssociationsMixin<MatchSetModel, MatchSetId>;
+    hasHome_libero_MatchSet: Sequelize.HasManyHasAssociationMixin<MatchSetModel, MatchSetId>;
+    hasHome_libero_MatchSets: Sequelize.HasManyHasAssociationsMixin<MatchSetModel, MatchSetId>;
+    countHome_libero_MatchSets: Sequelize.HasManyCountAssociationsMixin;
+    match_set_id_MatchSets: MatchSetModel[];
+    getMatch_set_id_MatchSets: Sequelize.BelongsToManyGetAssociationsMixin<MatchSetModel>;
+    setMatch_set_id_MatchSets: Sequelize.BelongsToManySetAssociationsMixin<MatchSetModel, MatchSetId>;
+    addMatch_set_id_MatchSet: Sequelize.BelongsToManyAddAssociationMixin<MatchSetModel, MatchSetId>;
+    addMatch_set_id_MatchSets: Sequelize.BelongsToManyAddAssociationsMixin<MatchSetModel, MatchSetId>;
+    createMatch_set_id_MatchSet: Sequelize.BelongsToManyCreateAssociationMixin<MatchSetModel>;
+    removeMatch_set_id_MatchSet: Sequelize.BelongsToManyRemoveAssociationMixin<MatchSetModel, MatchSetId>;
+    removeMatch_set_id_MatchSets: Sequelize.BelongsToManyRemoveAssociationsMixin<MatchSetModel, MatchSetId>;
+    hasMatch_set_id_MatchSet: Sequelize.BelongsToManyHasAssociationMixin<MatchSetModel, MatchSetId>;
+    hasMatch_set_id_MatchSets: Sequelize.BelongsToManyHasAssociationsMixin<MatchSetModel, MatchSetId>;
+    countMatch_set_id_MatchSets: Sequelize.BelongsToManyCountAssociationsMixin;
+    MatchSetStats: MatchSetStatsModel[];
+    getMatchSetStats: Sequelize.HasManyGetAssociationsMixin<MatchSetStatsModel>;
+    setMatchSetStats: Sequelize.HasManySetAssociationsMixin<MatchSetStatsModel, MatchSetStatsId>;
+    addMatchSetStat: Sequelize.HasManyAddAssociationMixin<MatchSetStatsModel, MatchSetStatsId>;
+    addMatchSetStats: Sequelize.HasManyAddAssociationsMixin<MatchSetStatsModel, MatchSetStatsId>;
+    createMatchSetStat: Sequelize.HasManyCreateAssociationMixin<MatchSetStatsModel>;
+    removeMatchSetStat: Sequelize.HasManyRemoveAssociationMixin<MatchSetStatsModel, MatchSetStatsId>;
+    removeMatchSetStats: Sequelize.HasManyRemoveAssociationsMixin<MatchSetStatsModel, MatchSetStatsId>;
+    hasMatchSetStat: Sequelize.HasManyHasAssociationMixin<MatchSetStatsModel, MatchSetStatsId>;
+    hasMatchSetStats: Sequelize.HasManyHasAssociationsMixin<MatchSetStatsModel, MatchSetStatsId>;
+    countMatchSetStats: Sequelize.HasManyCountAssociationsMixin;
+    PerformanceStat: PerformanceStatsModel;
+    getPerformanceStat: Sequelize.HasOneGetAssociationMixin<PerformanceStatsModel>;
+    setPerformanceStat: Sequelize.HasOneSetAssociationMixin<PerformanceStatsModel, PerformanceStatsId>;
+    createPerformanceStat: Sequelize.HasOneCreateAssociationMixin<PerformanceStatsModel>;
+    rally_id_Rallies: RallyModel[];
+    getRally_id_Rallies: Sequelize.BelongsToManyGetAssociationsMixin<RallyModel>;
+    setRally_id_Rallies: Sequelize.BelongsToManySetAssociationsMixin<RallyModel, RallyId>;
+    addRally_id_Rally: Sequelize.BelongsToManyAddAssociationMixin<RallyModel, RallyId>;
+    addRally_id_Rallies: Sequelize.BelongsToManyAddAssociationsMixin<RallyModel, RallyId>;
+    createRally_id_Rally: Sequelize.BelongsToManyCreateAssociationMixin<RallyModel>;
+    removeRally_id_Rally: Sequelize.BelongsToManyRemoveAssociationMixin<RallyModel, RallyId>;
+    removeRally_id_Rallies: Sequelize.BelongsToManyRemoveAssociationsMixin<RallyModel, RallyId>;
+    hasRally_id_Rally: Sequelize.BelongsToManyHasAssociationMixin<RallyModel, RallyId>;
+    hasRally_id_Rallies: Sequelize.BelongsToManyHasAssociationsMixin<RallyModel, RallyId>;
+    countRally_id_Rallies: Sequelize.BelongsToManyCountAssociationsMixin;
+    RallyPositions: RallyPositionModel[];
+    getRallyPositions: Sequelize.HasManyGetAssociationsMixin<RallyPositionModel>;
+    setRallyPositions: Sequelize.HasManySetAssociationsMixin<RallyPositionModel, RallyPositionId>;
+    addRallyPosition: Sequelize.HasManyAddAssociationMixin<RallyPositionModel, RallyPositionId>;
+    addRallyPositions: Sequelize.HasManyAddAssociationsMixin<RallyPositionModel, RallyPositionId>;
+    createRallyPosition: Sequelize.HasManyCreateAssociationMixin<RallyPositionModel>;
+    removeRallyPosition: Sequelize.HasManyRemoveAssociationMixin<RallyPositionModel, RallyPositionId>;
+    removeRallyPositions: Sequelize.HasManyRemoveAssociationsMixin<RallyPositionModel, RallyPositionId>;
+    hasRallyPosition: Sequelize.HasManyHasAssociationMixin<RallyPositionModel, RallyPositionId>;
+    hasRallyPositions: Sequelize.HasManyHasAssociationsMixin<RallyPositionModel, RallyPositionId>;
+    countRallyPositions: Sequelize.HasManyCountAssociationsMixin;
+    Receptions: ReceptionModel[];
+    getReceptions: Sequelize.HasManyGetAssociationsMixin<ReceptionModel>;
+    setReceptions: Sequelize.HasManySetAssociationsMixin<ReceptionModel, ReceptionId>;
+    addReception: Sequelize.HasManyAddAssociationMixin<ReceptionModel, ReceptionId>;
+    addReceptions: Sequelize.HasManyAddAssociationsMixin<ReceptionModel, ReceptionId>;
+    createReception: Sequelize.HasManyCreateAssociationMixin<ReceptionModel>;
+    removeReception: Sequelize.HasManyRemoveAssociationMixin<ReceptionModel, ReceptionId>;
+    removeReceptions: Sequelize.HasManyRemoveAssociationsMixin<ReceptionModel, ReceptionId>;
+    hasReception: Sequelize.HasManyHasAssociationMixin<ReceptionModel, ReceptionId>;
+    hasReceptions: Sequelize.HasManyHasAssociationsMixin<ReceptionModel, ReceptionId>;
+    countReceptions: Sequelize.HasManyCountAssociationsMixin;
+    Scores: ScoreModel[];
+    getScores: Sequelize.HasManyGetAssociationsMixin<ScoreModel>;
+    setScores: Sequelize.HasManySetAssociationsMixin<ScoreModel, ScoreId>;
+    addScore: Sequelize.HasManyAddAssociationMixin<ScoreModel, ScoreId>;
+    addScores: Sequelize.HasManyAddAssociationsMixin<ScoreModel, ScoreId>;
+    createScore: Sequelize.HasManyCreateAssociationMixin<ScoreModel>;
+    removeScore: Sequelize.HasManyRemoveAssociationMixin<ScoreModel, ScoreId>;
+    removeScores: Sequelize.HasManyRemoveAssociationsMixin<ScoreModel, ScoreId>;
+    hasScore: Sequelize.HasManyHasAssociationMixin<ScoreModel, ScoreId>;
+    hasScores: Sequelize.HasManyHasAssociationsMixin<ScoreModel, ScoreId>;
+    countScores: Sequelize.HasManyCountAssociationsMixin;
+    Serves: ServeModel[];
+    getServes: Sequelize.HasManyGetAssociationsMixin<ServeModel>;
+    setServes: Sequelize.HasManySetAssociationsMixin<ServeModel, ServeId>;
+    addSerf: Sequelize.HasManyAddAssociationMixin<ServeModel, ServeId>;
+    addServes: Sequelize.HasManyAddAssociationsMixin<ServeModel, ServeId>;
+    createSerf: Sequelize.HasManyCreateAssociationMixin<ServeModel>;
+    removeSerf: Sequelize.HasManyRemoveAssociationMixin<ServeModel, ServeId>;
+    removeServes: Sequelize.HasManyRemoveAssociationsMixin<ServeModel, ServeId>;
+    hasSerf: Sequelize.HasManyHasAssociationMixin<ServeModel, ServeId>;
+    hasServes: Sequelize.HasManyHasAssociationsMixin<ServeModel, ServeId>;
+    countServes: Sequelize.HasManyCountAssociationsMixin;
+    Sets: SetModel[];
+    getSets: Sequelize.HasManyGetAssociationsMixin<SetModel>;
+    setSets: Sequelize.HasManySetAssociationsMixin<SetModel, SetId>;
+    addSet: Sequelize.HasManyAddAssociationMixin<SetModel, SetId>;
+    addSets: Sequelize.HasManyAddAssociationsMixin<SetModel, SetId>;
+    createSet: Sequelize.HasManyCreateAssociationMixin<SetModel>;
+    removeSet: Sequelize.HasManyRemoveAssociationMixin<SetModel, SetId>;
+    removeSets: Sequelize.HasManyRemoveAssociationsMixin<SetModel, SetId>;
+    hasSet: Sequelize.HasManyHasAssociationMixin<SetModel, SetId>;
+    hasSets: Sequelize.HasManyHasAssociationsMixin<SetModel, SetId>;
+    countSets: Sequelize.HasManyCountAssociationsMixin;
+    Spikes: SpikeModel[];
+    getSpikes: Sequelize.HasManyGetAssociationsMixin<SpikeModel>;
+    setSpikes: Sequelize.HasManySetAssociationsMixin<SpikeModel, SpikeId>;
+    addSpike: Sequelize.HasManyAddAssociationMixin<SpikeModel, SpikeId>;
+    addSpikes: Sequelize.HasManyAddAssociationsMixin<SpikeModel, SpikeId>;
+    createSpike: Sequelize.HasManyCreateAssociationMixin<SpikeModel>;
+    removeSpike: Sequelize.HasManyRemoveAssociationMixin<SpikeModel, SpikeId>;
+    removeSpikes: Sequelize.HasManyRemoveAssociationsMixin<SpikeModel, SpikeId>;
+    hasSpike: Sequelize.HasManyHasAssociationMixin<SpikeModel, SpikeId>;
+    hasSpikes: Sequelize.HasManyHasAssociationsMixin<SpikeModel, SpikeId>;
+    countSpikes: Sequelize.HasManyCountAssociationsMixin;
+    Substitutions: SubstitutionModel[];
+    getSubstitutions: Sequelize.HasManyGetAssociationsMixin<SubstitutionModel>;
+    setSubstitutions: Sequelize.HasManySetAssociationsMixin<SubstitutionModel, SubstitutionId>;
+    addSubstitution: Sequelize.HasManyAddAssociationMixin<SubstitutionModel, SubstitutionId>;
+    addSubstitutions: Sequelize.HasManyAddAssociationsMixin<SubstitutionModel, SubstitutionId>;
+    createSubstitution: Sequelize.HasManyCreateAssociationMixin<SubstitutionModel>;
+    removeSubstitution: Sequelize.HasManyRemoveAssociationMixin<SubstitutionModel, SubstitutionId>;
+    removeSubstitutions: Sequelize.HasManyRemoveAssociationsMixin<SubstitutionModel, SubstitutionId>;
+    hasSubstitution: Sequelize.HasManyHasAssociationMixin<SubstitutionModel, SubstitutionId>;
+    hasSubstitutions: Sequelize.HasManyHasAssociationsMixin<SubstitutionModel, SubstitutionId>;
+    countSubstitutions: Sequelize.HasManyCountAssociationsMixin;
+    player_Substitutions: SubstitutionModel[];
+    getPlayer_Substitutions: Sequelize.HasManyGetAssociationsMixin<SubstitutionModel>;
+    setPlayer_Substitutions: Sequelize.HasManySetAssociationsMixin<SubstitutionModel, SubstitutionId>;
+    addPlayer_Substitution: Sequelize.HasManyAddAssociationMixin<SubstitutionModel, SubstitutionId>;
+    addPlayer_Substitutions: Sequelize.HasManyAddAssociationsMixin<SubstitutionModel, SubstitutionId>;
+    createPlayer_Substitution: Sequelize.HasManyCreateAssociationMixin<SubstitutionModel>;
+    removePlayer_Substitution: Sequelize.HasManyRemoveAssociationMixin<SubstitutionModel, SubstitutionId>;
+    removePlayer_Substitutions: Sequelize.HasManyRemoveAssociationsMixin<SubstitutionModel, SubstitutionId>;
+    hasPlayer_Substitution: Sequelize.HasManyHasAssociationMixin<SubstitutionModel, SubstitutionId>;
+    hasPlayer_Substitutions: Sequelize.HasManyHasAssociationsMixin<SubstitutionModel, SubstitutionId>;
+    countPlayer_Substitutions: Sequelize.HasManyCountAssociationsMixin;
+    team: TeamModel;
+    getTeam: Sequelize.BelongsToGetAssociationMixin<TeamModel>;
+    setTeam: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>;
+    createTeam: Sequelize.BelongsToCreateAssociationMixin<TeamModel>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof PlayerModel;
+}