volleyballsimtypes 0.0.359 → 0.0.361

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

@@ -0,0 +1,30 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import { PlayerId, PlayerModel, TeamId, TeamModel } from '.';
+export interface PlayerTeamAttributes {
+    player_id: string;
+    team_id: string;
+    jersey_number: number;
+    active: boolean;
+    locked: boolean;
+}
+export type PlayerTeamPk = 'player_id' | 'team_id';
+export type PlayerTeamId = PlayerTeamModel[PlayerTeamPk];
+export type PlayerTeamOptionalAttributes = 'jersey_number' | 'locked';
+export type PlayerTeamCreationAttributes = Optional<PlayerTeamAttributes, PlayerTeamOptionalAttributes>;
+export declare class PlayerTeamModel extends Model<PlayerTeamAttributes, PlayerTeamCreationAttributes> implements PlayerTeamAttributes {
+    player_id: string;
+    team_id: string;
+    jersey_number: number;
+    active: boolean;
+    locked: boolean;
+    player: PlayerModel;
+    getPlayer: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
+    setPlayer: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;
+    createPlayer: Sequelize.BelongsToCreateAssociationMixin<PlayerModel>;
+    team: TeamModel;
+    getTeam: Sequelize.BelongsToGetAssociationMixin<TeamModel>;
+    setTeam: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>;
+    createTeam: Sequelize.BelongsToCreateAssociationMixin<TeamModel>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof PlayerTeamModel;
+}

package/dist/cjs/src/data/models/player-team.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlayerTeamModel = void 0;
+const sequelize_1 = require("sequelize");
+class PlayerTeamModel extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return PlayerTeamModel.init({
+            player_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'Player',
+                    key: 'player_id'
+                }
+            },
+            team_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'Team',
+                    key: 'team_id'
+                }
+            },
+            jersey_number: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false,
+                defaultValue: 1
+            },
+            active: {
+                type: sequelize_1.DataTypes.BOOLEAN,
+                allowNull: false,
+                defaultValue: false
+            },
+            locked: {
+                type: sequelize_1.DataTypes.BOOLEAN,
+                allowNull: false,
+                defaultValue: false
+            }
+        }, {
+            sequelize,
+            tableName: 'PlayerTeam',
+            schema: 'public',
+            timestamps: false,
+            indexes: [{
+                    name: 'PlayerTeam_pk',
+                    unique: true,
+                    fields: [
+                        { name: 'player_id' },
+                        { name: 'team_id' }
+                    ]
+                }]
+        });
+    }
+}
+exports.PlayerTeamModel = PlayerTeamModel;

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

@@ -0,0 +1,110 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { BoxScoreAttributes, BoxScoreId, BoxScoreModel, BoxScoreTotalsId, BoxScoreTotalsModel, CompetitionMVPId, CompetitionMVPModel, CountryId, CountryModel, MatchSetId, MatchSetModel, PerformanceStatsAttributes, PerformanceStatsId, PerformanceStatsModel, PlayerTeamId, PlayerTeamModel, TeamId, TeamModel, VPERId, VPERModel } from '.';
+import { DeclineProfile, Rarity, Role, Trait } from '../../service';
+export interface PlayerAttributes {
+    player_id: string;
+    roles: Role[];
+    traits: Trait[];
+    rarity: Rarity;
+    first_name: string;
+    last_name: string;
+    country_id: string;
+    age: number;
+    decline_profile: DeclineProfile;
+    PerformanceStat?: PerformanceStatsAttributes;
+    BoxScores?: BoxScoreAttributes[];
+}
+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;
+    roles: Role[];
+    traits: Trait[];
+    rarity: Rarity;
+    first_name: string;
+    last_name: string;
+    country_id: string;
+    age: number;
+    decline_profile: DeclineProfile;
+    country: CountryModel;
+    getCountry: Sequelize.BelongsToGetAssociationMixin<CountryModel>;
+    setCountry: Sequelize.BelongsToSetAssociationMixin<CountryModel, CountryId>;
+    createCountry: Sequelize.BelongsToCreateAssociationMixin<CountryModel>;
+    StatsMatchSets: MatchSetModel[];
+    getStatsMatchSets: Sequelize.BelongsToManyGetAssociationsMixin<MatchSetModel>;
+    setStatsMatchSets: Sequelize.BelongsToManySetAssociationsMixin<MatchSetModel, MatchSetId>;
+    addStatsMatchSet: Sequelize.BelongsToManyAddAssociationMixin<MatchSetModel, MatchSetId>;
+    addStatsMatchSets: Sequelize.BelongsToManyAddAssociationsMixin<MatchSetModel, MatchSetId>;
+    createStatsMatchSet: Sequelize.BelongsToManyCreateAssociationMixin<MatchSetModel>;
+    removeStatsMatchSet: Sequelize.BelongsToManyRemoveAssociationMixin<MatchSetModel, MatchSetId>;
+    removeStatsMatchSets: Sequelize.BelongsToManyRemoveAssociationsMixin<MatchSetModel, MatchSetId>;
+    hasStatsMatchSet: Sequelize.BelongsToManyHasAssociationMixin<MatchSetModel, MatchSetId>;
+    hasStatsMatchSets: Sequelize.BelongsToManyHasAssociationsMixin<MatchSetModel, MatchSetId>;
+    countStatsMatchSets: Sequelize.BelongsToManyCountAssociationsMixin;
+    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;
+    PerformanceStat: PerformanceStatsModel;
+    getPerformanceStat: Sequelize.HasOneGetAssociationMixin<PerformanceStatsModel>;
+    setPerformanceStat: Sequelize.HasOneSetAssociationMixin<PerformanceStatsModel, PerformanceStatsId>;
+    createPerformanceStat: Sequelize.HasOneCreateAssociationMixin<PerformanceStatsModel>;
+    BoxScoreTotals: BoxScoreTotalsModel;
+    getBoxScoreTotals: Sequelize.HasOneGetAssociationMixin<BoxScoreTotalsModel>;
+    setBoxScoreTotals: Sequelize.HasOneSetAssociationMixin<BoxScoreTotalsModel, BoxScoreTotalsId>;
+    createBoxScoreTotals: Sequelize.HasOneCreateAssociationMixin<BoxScoreTotalsModel>;
+    VPERs: VPERModel[];
+    getVPERs: Sequelize.HasManyGetAssociationsMixin<VPERModel>;
+    setVPERs: Sequelize.HasManySetAssociationsMixin<VPERModel, VPERId>;
+    addVPER: Sequelize.HasManyAddAssociationMixin<VPERModel, VPERId>;
+    addVPERs: Sequelize.HasManyAddAssociationsMixin<VPERModel, VPERId>;
+    createVPER: Sequelize.HasManyCreateAssociationMixin<VPERModel>;
+    removeVPER: Sequelize.HasManyRemoveAssociationMixin<VPERModel, VPERId>;
+    removeVPERs: Sequelize.HasManyRemoveAssociationsMixin<VPERModel, VPERId>;
+    hasVPER: Sequelize.HasManyHasAssociationMixin<VPERModel, VPERId>;
+    hasVPERs: Sequelize.HasManyHasAssociationsMixin<VPERModel, VPERId>;
+    countVPERs: Sequelize.HasManyCountAssociationsMixin;
+    CompetitionMVPs: CompetitionMVPModel[];
+    getCompetitionMVPs: Sequelize.HasManyGetAssociationsMixin<CompetitionMVPModel>;
+    setCompetitionMVPs: Sequelize.HasManySetAssociationsMixin<CompetitionMVPModel, CompetitionMVPId>;
+    addCompetitionMVP: Sequelize.HasManyAddAssociationMixin<CompetitionMVPModel, CompetitionMVPId>;
+    addCompetitionMVPs: Sequelize.HasManyAddAssociationsMixin<CompetitionMVPModel, CompetitionMVPId>;
+    createCompetitionMVP: Sequelize.HasManyCreateAssociationMixin<CompetitionMVPModel>;
+    removeCompetitionMVP: Sequelize.HasManyRemoveAssociationMixin<CompetitionMVPModel, CompetitionMVPId>;
+    removeCompetitionMVPs: Sequelize.HasManyRemoveAssociationsMixin<CompetitionMVPModel, CompetitionMVPId>;
+    hasCompetitionMVP: Sequelize.HasManyHasAssociationMixin<CompetitionMVPModel, CompetitionMVPId>;
+    hasCompetitionMVPs: Sequelize.HasManyHasAssociationsMixin<CompetitionMVPModel, CompetitionMVPId>;
+    countCompetitionMVPs: Sequelize.HasManyCountAssociationsMixin;
+    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;
+    Teams: TeamModel[];
+    getTeams: Sequelize.BelongsToManyGetAssociationsMixin<TeamModel>;
+    setTeams: Sequelize.BelongsToManySetAssociationsMixin<TeamModel, TeamId>;
+    addTeam: Sequelize.BelongsToManyAddAssociationMixin<TeamModel, TeamId>;
+    addTeams: Sequelize.BelongsToManyAddAssociationsMixin<TeamModel, TeamId>;
+    createTeam: Sequelize.BelongsToManyCreateAssociationMixin<TeamModel>;
+    removeTeam: Sequelize.BelongsToManyRemoveAssociationMixin<TeamModel, TeamId>;
+    removeTeams: Sequelize.BelongsToManyRemoveAssociationsMixin<TeamModel, TeamId>;
+    hasTeam: Sequelize.BelongsToManyHasAssociationMixin<TeamModel, TeamId>;
+    hasTeams: Sequelize.BelongsToManyHasAssociationsMixin<TeamModel, TeamId>;
+    countTeams: Sequelize.BelongsToManyCountAssociationsMixin;
+    static initModel(sequelize: Sequelize.Sequelize): typeof PlayerModel;
+}

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

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlayerModel = void 0;
+const sequelize_1 = require("sequelize");
+const _1 = require(".");
+const service_1 = require("../../service");
+class PlayerModel extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return PlayerModel.init({
+            player_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true
+            },
+            roles: {
+                type: sequelize_1.DataTypes.ARRAY(sequelize_1.DataTypes.ENUM(...Object.values(service_1.RoleEnum))),
+                allowNull: false
+            },
+            traits: {
+                type: sequelize_1.DataTypes.ARRAY(sequelize_1.DataTypes.ENUM(...Object.values(service_1.TraitEnum))),
+                allowNull: false
+            },
+            rarity: {
+                type: sequelize_1.DataTypes.ENUM(...Object.values(service_1.RarityEnum)),
+                allowNull: false
+            },
+            first_name: {
+                type: sequelize_1.DataTypes.STRING,
+                allowNull: false
+            },
+            last_name: {
+                type: sequelize_1.DataTypes.STRING,
+                allowNull: false
+            },
+            country_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'Country',
+                    key: 'country_id'
+                }
+            },
+            age: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false,
+                defaultValue: 17
+            },
+            decline_profile: {
+                type: sequelize_1.DataTypes.ENUM(...Object.values(service_1.DeclineProfileEnum)),
+                allowNull: false,
+                defaultValue: service_1.DeclineProfileEnum.STANDARD
+            }
+        }, {
+            sequelize,
+            tableName: 'Player',
+            schema: 'public',
+            timestamps: false,
+            defaultScope: {
+                include: [
+                    { model: _1.CountryModel, as: 'country' },
+                    { model: _1.PerformanceStatsModel, as: 'PerformanceStat' }
+                ]
+            },
+            indexes: [{
+                    name: 'Player_pk',
+                    unique: true,
+                    fields: [{ name: 'player_id' }]
+                }]
+        });
+    }
+}
+exports.PlayerModel = PlayerModel;

package/dist/cjs/src/data/models/promotion-match.d.ts

@@ -0,0 +1,36 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { CompetitionId, CompetitionModel, IterationId, IterationModel, MatchAttributes, MatchId, MatchModel } from '.';
+export interface PromotionMatchAttributes {
+    iteration: number;
+    match_id: string;
+    upper_competition: string;
+    lower_competition: string;
+    match?: MatchAttributes;
+}
+export type PromotionMatchPk = 'match_id';
+export type PromotionMatchId = PromotionMatchModel[PromotionMatchPk];
+export type PromotionMatchCreationAttributes = PromotionMatchAttributes;
+export declare class PromotionMatchModel extends Model<PromotionMatchAttributes, PromotionMatchCreationAttributes> implements PromotionMatchAttributes {
+    iteration: number;
+    match_id: string;
+    upper_competition: string;
+    lower_competition: string;
+    iterationData: IterationModel;
+    getIterationData: Sequelize.BelongsToGetAssociationMixin<IterationModel>;
+    setIterationData: Sequelize.BelongsToSetAssociationMixin<IterationModel, IterationId>;
+    createIterationData: Sequelize.BelongsToCreateAssociationMixin<IterationModel>;
+    Match: MatchModel;
+    getMatch: Sequelize.BelongsToGetAssociationMixin<MatchModel>;
+    setMatch: Sequelize.BelongsToSetAssociationMixin<MatchModel, MatchId>;
+    createMatch: Sequelize.BelongsToCreateAssociationMixin<MatchModel>;
+    upperCompetition: CompetitionModel;
+    getUpperCompetition: Sequelize.BelongsToGetAssociationMixin<CompetitionModel>;
+    setUpperCompetition: Sequelize.BelongsToSetAssociationMixin<CompetitionModel, CompetitionId>;
+    createUpperCompetition: Sequelize.BelongsToCreateAssociationMixin<CompetitionModel>;
+    lowerCompetition: CompetitionModel;
+    getLowerCompetition: Sequelize.BelongsToGetAssociationMixin<CompetitionModel>;
+    setLowerCompetition: Sequelize.BelongsToSetAssociationMixin<CompetitionModel, CompetitionId>;
+    createLowerCompetition: Sequelize.BelongsToCreateAssociationMixin<CompetitionModel>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof PromotionMatchModel;
+}

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

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromotionMatchModel = void 0;
+const sequelize_1 = require("sequelize");
+class PromotionMatchModel extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return PromotionMatchModel.init({
+            iteration: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false,
+                references: {
+                    model: 'Iteration',
+                    key: 'iteration_id'
+                }
+            },
+            match_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'Match',
+                    key: 'match_id'
+                }
+            },
+            upper_competition: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'Competition',
+                    key: 'competition_id'
+                }
+            },
+            lower_competition: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'Competition',
+                    key: 'competition_id'
+                }
+            }
+        }, {
+            sequelize,
+            tableName: 'PromotionMatch',
+            schema: 'public',
+            timestamps: false
+        });
+    }
+}
+exports.PromotionMatchModel = PromotionMatchModel;

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

@@ -0,0 +1,29 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { MatchSetId, MatchSetModel, TeamId, TeamModel } from '.';
+export interface RallyAttributes {
+    rally_id: string;
+    match_set_id: string;
+    serving_team: string;
+    order: number;
+    events: Buffer;
+}
+export type RallyPk = 'rally_id';
+export type RallyId = RallyModel[RallyPk];
+export type RallyCreationAttributes = RallyAttributes;
+export declare class RallyModel extends Model<RallyAttributes, RallyCreationAttributes> implements RallyAttributes {
+    rally_id: string;
+    match_set_id: string;
+    serving_team: string;
+    order: number;
+    events: Buffer;
+    matchSet: MatchSetModel;
+    getMatchSet: Sequelize.BelongsToGetAssociationMixin<MatchSetModel>;
+    setMatchSet: Sequelize.BelongsToSetAssociationMixin<MatchSetModel, MatchSetId>;
+    createMatchSet: Sequelize.BelongsToCreateAssociationMixin<MatchSetModel>;
+    ServingTeam: TeamModel;
+    getServingTeam: Sequelize.BelongsToGetAssociationMixin<TeamModel>;
+    setServingTeam: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>;
+    createServingTeam: Sequelize.BelongsToCreateAssociationMixin<TeamModel>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof RallyModel;
+}

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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RallyModel = void 0;
+const sequelize_1 = require("sequelize");
+class RallyModel extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return RallyModel.init({
+            rally_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true
+            },
+            match_set_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'MatchSet',
+                    key: 'match_set_id'
+                }
+            },
+            serving_team: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'Team',
+                    key: 'team_id'
+                }
+            },
+            order: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false
+            },
+            events: {
+                type: sequelize_1.DataTypes.BLOB,
+                allowNull: false
+            }
+        }, {
+            sequelize,
+            tableName: 'Rally',
+            schema: 'public',
+            timestamps: false,
+            indexes: [{
+                    name: 'Rally_pk',
+                    unique: true,
+                    fields: [{ name: 'rally_id' }]
+                }]
+        });
+    }
+}
+exports.RallyModel = RallyModel;

package/dist/cjs/src/data/models/region-qualifier.d.ts

@@ -0,0 +1,29 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { CompetitionId, CompetitionModel, CountryId, CountryModel, IterationId, IterationModel } from '.';
+export interface RegionQualifierAttributes {
+    iteration: number;
+    region_code: string;
+    competition_id: string;
+}
+export type RegionQualifierPk = 'iteration' | 'region_code';
+export type RegionQualifierId = RegionQualifierModel[RegionQualifierPk];
+export type RegionQualifierCreationAttributes = RegionQualifierAttributes;
+export declare class RegionQualifierModel extends Model<RegionQualifierAttributes, RegionQualifierCreationAttributes> implements RegionQualifierAttributes {
+    iteration: number;
+    region_code: string;
+    competition_id: string;
+    Iteration: IterationModel;
+    getIteration: Sequelize.BelongsToGetAssociationMixin<IterationModel>;
+    setIteration: Sequelize.BelongsToSetAssociationMixin<IterationModel, IterationId>;
+    createIteration: Sequelize.BelongsToCreateAssociationMixin<IterationModel>;
+    competition: CompetitionModel;
+    getCompetition: Sequelize.BelongsToGetAssociationMixin<CompetitionModel>;
+    setCompetition: Sequelize.BelongsToSetAssociationMixin<CompetitionModel, CompetitionId>;
+    createCompetition: Sequelize.BelongsToCreateAssociationMixin<CompetitionModel>;
+    countryRegion: CountryModel;
+    getCountryRegion: Sequelize.BelongsToGetAssociationMixin<CountryModel>;
+    setCountryRegion: Sequelize.BelongsToSetAssociationMixin<CountryModel, CountryId>;
+    createCountryRegion: Sequelize.BelongsToCreateAssociationMixin<CountryModel>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof RegionQualifierModel;
+}

package/dist/cjs/src/data/models/region-qualifier.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegionQualifierModel = void 0;
+const sequelize_1 = require("sequelize");
+class RegionQualifierModel extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return RegionQualifierModel.init({
+            iteration: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'Iteration',
+                    key: 'iteration_id'
+                }
+            },
+            region_code: {
+                type: sequelize_1.DataTypes.STRING(3),
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'Country',
+                    key: 'region_code'
+                }
+            },
+            competition_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'Competition',
+                    key: 'competition_id'
+                }
+            }
+        }, {
+            sequelize,
+            tableName: 'RegionQualifier',
+            schema: 'public',
+            timestamps: false,
+            indexes: [{
+                    name: 'regionqualifier_pk',
+                    unique: true,
+                    fields: [{ name: 'iteration' }, { name: 'region_code' }]
+                }]
+        });
+    }
+}
+exports.RegionQualifierModel = RegionQualifierModel;

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

@@ -0,0 +1,27 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { PlayerId, PlayerModel, TeamId, TeamModel } from '.';
+export interface RetiredPlayerAttributes {
+    player_id: string;
+    user_id: string;
+    team_id: string;
+    retired_iteration: number;
+}
+export type RetiredPlayerPk = 'player_id';
+export type RetiredPlayerId = RetiredPlayerModel[RetiredPlayerPk];
+export type RetiredPlayerCreationAttributes = RetiredPlayerAttributes;
+export declare class RetiredPlayerModel extends Model<RetiredPlayerAttributes, RetiredPlayerCreationAttributes> implements RetiredPlayerAttributes {
+    player_id: string;
+    user_id: string;
+    team_id: string;
+    retired_iteration: number;
+    player: PlayerModel;
+    getPlayer: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
+    setPlayer: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;
+    createPlayer: Sequelize.BelongsToCreateAssociationMixin<PlayerModel>;
+    team: TeamModel;
+    getTeam: Sequelize.BelongsToGetAssociationMixin<TeamModel>;
+    setTeam: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>;
+    createTeam: Sequelize.BelongsToCreateAssociationMixin<TeamModel>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof RetiredPlayerModel;
+}

package/dist/cjs/src/data/models/retired-player.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RetiredPlayerModel = void 0;
+const sequelize_1 = require("sequelize");
+class RetiredPlayerModel extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return RetiredPlayerModel.init({
+            player_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'Player',
+                    key: 'player_id'
+                }
+            },
+            user_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'AuthUser',
+                    key: 'user_id'
+                }
+            },
+            team_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'Team',
+                    key: 'team_id'
+                }
+            },
+            retired_iteration: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false
+            }
+        }, {
+            sequelize,
+            tableName: 'RetiredPlayer',
+            schema: 'public',
+            timestamps: false,
+            indexes: [{
+                    name: 'RetiredPlayer_pk',
+                    unique: true,
+                    fields: [{ name: 'player_id' }]
+                }]
+        });
+    }
+}
+exports.RetiredPlayerModel = RetiredPlayerModel;

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

@@ -0,0 +1,38 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import { PlayerId, TeamId, TeamModel } from '.';
+import { CourtPosition } from '../../service';
+export interface TacticsLineupAttributes {
+    [CourtPosition.LIBERO_ZONE]?: PlayerId;
+    [CourtPosition.LEFT_BACK]: PlayerId;
+    [CourtPosition.LEFT_FRONT]: PlayerId;
+    [CourtPosition.MIDDLE_BACK]: PlayerId;
+    [CourtPosition.MIDDLE_FRONT]: PlayerId;
+    [CourtPosition.RIGHT_BACK]: PlayerId;
+    [CourtPosition.RIGHT_FRONT]: PlayerId;
+    bench: PlayerId[];
+}
+export type PinchServerSubsAttributes = Record<PlayerId, PlayerId>;
+export interface TacticsAttributes {
+    team_id: string;
+    substitution_tolerance: number;
+    lineup: TacticsLineupAttributes;
+    libero_replacements: PlayerId[];
+    pinch_server_subs: PinchServerSubsAttributes;
+}
+export type TacticsPk = 'team_id';
+export type TacticsId = TacticsModel[TacticsPk];
+export type TacticsOptionalAttributes = 'substitution_tolerance' | 'lineup' | 'libero_replacements' | 'pinch_server_subs';
+export type TacticsCreationAttributes = Optional<TacticsAttributes, TacticsOptionalAttributes>;
+export declare class TacticsModel extends Model<TacticsAttributes, TacticsCreationAttributes> implements TacticsAttributes {
+    team_id: string;
+    substitution_tolerance: number;
+    lineup: TacticsLineupAttributes;
+    libero_replacements: PlayerId[];
+    pinch_server_subs: PinchServerSubsAttributes;
+    team: TeamModel;
+    getTeam: Sequelize.BelongsToGetAssociationMixin<TeamModel>;
+    setTeam: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>;
+    createTeam: Sequelize.BelongsToCreateAssociationMixin<TeamModel>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof TacticsModel;
+}