volleyballsimtypes 0.0.523 → 0.0.525

package/dist/cjs/src/api/index.d.ts

@@ -70,6 +70,8 @@ export type ChampionBadgeSpec = {
     region: ChampionRegion;
 } | {
     type: 'wcc';
+} | {
+    type: 'wnl';
 };
 export type Player = Omit<DataProps<_Player>, 'stats' | 'birthAge' | 'birthIteration' | 'declineProfile' | 'nickname' | 'injuryProneProfile' | 'injury'> & {
     -readonly [K in 'birthAge' | 'birthIteration']?: DataProps<_Player>[K];
@@ -83,6 +85,7 @@ export type Player = Omit<DataProps<_Player>, 'stats' | 'birthAge' | 'birthItera
     nickname?: string;
     jerseyConfig?: JerseyConfig;
     championBadge?: ChampionBadgeSpec;
+    nationalFlagAlpha2?: string;
 };
 export interface StartingLineup {
     [CourtPosition.LEFT_FRONT]: string;
@@ -189,6 +192,12 @@ export type Team = Omit<DataProps<_Team>, 'roster' | '_rating' | 'rating' | 'tac
     };
     nationalCountryName?: string;
     isEvent?: boolean;
+    isNational?: boolean;
+    nationalManager?: {
+        displayName: string;
+        teamId: string;
+        teamShortName: string;
+    };
 };
 export type Standing = DataProps<_Standing> & {
     position: number;
@@ -255,4 +264,11 @@ export type TotalBoxScore = Omit<DataProps<BoxScore>, 'misc' | 'playerId' | 'mat
         setsPlayed: number;
         matchesPlayed: number;
     };
+    national?: {
+        alpha2: string;
+        matchesPlayed: number;
+        matchesWon: number;
+        pointsPlayed: number;
+        pointsWon: number;
+    };
 };

package/dist/cjs/src/data/init-models.js

@@ -61,10 +61,16 @@ function initModels(sequelize) {
     const PlayerTeam = models_1.PlayerTeamModel.initModel(sequelize);
     const RetiredPlayer = models_1.RetiredPlayerModel.initModel(sequelize);
     const Rally = models_1.RallyModel.initModel(sequelize);
+    const MatchInputSnapshot = models_1.MatchInputSnapshotModel.initModel(sequelize);
     const PromotionMatch = models_1.PromotionMatchModel.initModel(sequelize);
     const Friendly = models_1.FriendlyModel.initModel(sequelize);
     const RegionQualifier = models_1.RegionQualifierModel.initModel(sequelize);
     const NationalCountry = models_1.NationalCountryModel.initModel(sequelize);
+    const NationalTeam = models_1.NationalTeamModel.initModel(sequelize);
+    const NationalTeamClaim = models_1.NationalTeamClaimModel.initModel(sequelize);
+    const WnlSquad = models_1.WnlSquadModel.initModel(sequelize);
+    const WnlCallup = models_1.WnlCallupModel.initModel(sequelize);
+    const WnlSeason = models_1.WnlSeasonModel.initModel(sequelize);
     const Team = models_1.TeamModel.initModel(sequelize);
     const TeamReplacement = models_1.TeamReplacementModel.initModel(sequelize);
     const LegacyTeamFlag = models_1.LegacyTeamFlagModel.initModel(sequelize);
@@ -162,6 +168,8 @@ function initModels(sequelize) {
     Match.hasOne(CompetitionMatch, { as: 'CompetitionMatch', foreignKey: 'match_id' });
     Match.hasOne(MatchResult, { as: 'MatchResult', foreignKey: 'match_id' });
     Match.hasOne(Friendly, { as: 'Friendly', foreignKey: 'match_id' });
+    Match.hasOne(MatchInputSnapshot, { as: 'MatchInputSnapshot', foreignKey: 'match_id' });
+    MatchInputSnapshot.belongsTo(Match, { as: 'Match', foreignKey: 'match_id' });
     MatchResult.belongsTo(Match, { as: 'Match', foreignKey: 'match_id' });
     MatchResult.belongsTo(Team, { as: 'Winner', foreignKey: 'winner_team_id' });
     MatchRating.belongsTo(Match, { as: 'match', foreignKey: 'match_id' });
@@ -228,6 +236,28 @@ function initModels(sequelize) {
     Competition.hasOne(NationalCountry, { as: 'NationalCountry', foreignKey: 'competition_id' });
     Country.hasMany(NationalCountry, { as: 'NationalCountries', foreignKey: 'country_id' });
     Iteration.hasMany(NationalCountry, { as: 'NationalCountries', foreignKey: 'iteration' });
+    // National teams (WNL). The registry maps a country to its permanent active=false national Team; the claim links a
+    // Tier-2 manager to it; per-edition squad + callup + season rows hang off the WNL league Competition.
+    NationalTeam.belongsTo(Country, { as: 'country', foreignKey: 'country_id' });
+    NationalTeam.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
+    Country.hasOne(NationalTeam, { as: 'NationalTeam', foreignKey: 'country_id' });
+    Team.hasOne(NationalTeam, { as: 'NationalTeam', foreignKey: 'team_id' });
+    NationalTeam.hasOne(NationalTeamClaim, { as: 'claim', foreignKey: 'country_id' });
+    NationalTeamClaim.belongsTo(NationalTeam, { as: 'nationalTeam', foreignKey: 'country_id' });
+    NationalTeamClaim.belongsTo(AuthUser, { as: 'user', foreignKey: 'user_id' });
+    AuthUser.hasOne(NationalTeamClaim, { as: 'NationalTeamClaim', foreignKey: 'user_id' });
+    WnlSquad.belongsTo(Competition, { as: 'competition', foreignKey: 'competition_id' });
+    WnlSquad.belongsTo(Country, { as: 'country', foreignKey: 'country_id' });
+    WnlSquad.belongsTo(Team, { as: 'team', foreignKey: 'team_id' });
+    WnlSquad.belongsTo(AuthUser, { as: 'manager', foreignKey: 'manager_user_id' });
+    Competition.hasMany(WnlSquad, { as: 'WnlSquads', foreignKey: 'competition_id' });
+    WnlCallup.belongsTo(Competition, { as: 'competition', foreignKey: 'competition_id' });
+    WnlCallup.belongsTo(Player, { as: 'player', foreignKey: 'player_id' });
+    WnlCallup.belongsTo(Country, { as: 'country', foreignKey: 'country_id' });
+    Competition.hasMany(WnlCallup, { as: 'WnlCallups', foreignKey: 'competition_id' });
+    WnlSeason.belongsTo(Competition, { as: 'competition', foreignKey: 'competition_id' });
+    WnlSeason.belongsTo(Competition, { as: 'finalsCompetition', foreignKey: 'finals_competition_id' });
+    Competition.hasOne(WnlSeason, { as: 'WnlSeason', foreignKey: 'competition_id' });
     VPER.belongsTo(Player, { as: 'Player', foreignKey: 'player_id' });
     VPER.belongsTo(Match, { as: 'Match', foreignKey: 'match_id' });
     Team.hasOne(Coach, { as: 'Coach', foreignKey: 'team_id' });
@@ -351,6 +381,11 @@ function initModels(sequelize) {
         Friendly,
         RegionQualifier,
         NationalCountry,
+        NationalTeam,
+        NationalTeamClaim,
+        WnlSquad,
+        WnlCallup,
+        WnlSeason,
         Rally,
         Team,
         TeamReplacement,

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

@@ -21,7 +21,7 @@ export interface CompetitionAttributes {
     LowerPromotionMatches?: PromotionMatchAttributes[];
 }
 export type CompetitionPk = 'competition_id';
-export type CompetitionType = 'LEAGUE' | 'TOURNAMENT' | 'QUALIFIER' | 'NATIONAL' | 'EVENT';
+export type CompetitionType = 'LEAGUE' | 'TOURNAMENT' | 'QUALIFIER' | 'NATIONAL' | 'EVENT' | 'WNL' | 'WNLF';
 export type CompetitionId = CompetitionModel[CompetitionPk];
 export type CompetitionCreationAttributes = CompetitionAttributes;
 export declare class CompetitionModel extends Model<CompetitionAttributes, CompetitionCreationAttributes> implements CompetitionAttributes {

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

@@ -21,7 +21,7 @@ class CompetitionModel extends sequelize_1.Model {
                 }
             },
             type: {
-                type: sequelize_1.DataTypes.ENUM('LEAGUE', 'TOURNAMENT', 'QUALIFIER', 'NATIONAL', 'EVENT'),
+                type: sequelize_1.DataTypes.ENUM('LEAGUE', 'TOURNAMENT', 'QUALIFIER', 'NATIONAL', 'EVENT', 'WNL', 'WNLF'),
                 allowNull: false
             },
             status: {

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

@@ -27,10 +27,16 @@ export * from './player-decline-log';
 export * from './player-team';
 export * from './retired-player';
 export * from './rally';
+export * from './match-input-snapshot';
 export * from './promotion-match';
 export * from './friendly';
 export * from './region-qualifier';
 export * from './national-country';
+export * from './national-team';
+export * from './national-team-claim';
+export * from './wnl-squad';
+export * from './wnl-callup';
+export * from './wnl-season';
 export * from './coach';
 export * from './scout';
 export * from './physician';

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

@@ -43,10 +43,16 @@ __exportStar(require("./player-decline-log"), exports);
 __exportStar(require("./player-team"), exports);
 __exportStar(require("./retired-player"), exports);
 __exportStar(require("./rally"), exports);
+__exportStar(require("./match-input-snapshot"), exports);
 __exportStar(require("./promotion-match"), exports);
 __exportStar(require("./friendly"), exports);
 __exportStar(require("./region-qualifier"), exports);
 __exportStar(require("./national-country"), exports);
+__exportStar(require("./national-team"), exports);
+__exportStar(require("./national-team-claim"), exports);
+__exportStar(require("./wnl-squad"), exports);
+__exportStar(require("./wnl-callup"), exports);
+__exportStar(require("./wnl-season"), exports);
 __exportStar(require("./coach"), exports);
 __exportStar(require("./scout"), exports);
 __exportStar(require("./physician"), exports);

package/dist/cjs/src/data/models/jersey-badge.d.ts

@@ -1,7 +1,7 @@
 import * as Sequelize from 'sequelize';
 import { Model } from 'sequelize';
 import { CompetitionId, CompetitionModel, TeamId, TeamModel } from '.';
-export type JerseyBadgeKind = 'LEAGUE' | 'NATIONALS' | 'REGIONALS' | 'WCC';
+export type JerseyBadgeKind = 'LEAGUE' | 'NATIONALS' | 'REGIONALS' | 'WCC' | 'WNL';
 export interface JerseyBadgeAttributes {
     competition_id: string;
     team_id: string;

package/dist/cjs/src/data/models/jersey-badge.js

@@ -23,7 +23,7 @@ class JerseyBadgeModel extends sequelize_1.Model {
                 }
             },
             badge: {
-                type: sequelize_1.DataTypes.ENUM('LEAGUE', 'NATIONALS', 'REGIONALS', 'WCC'),
+                type: sequelize_1.DataTypes.ENUM('LEAGUE', 'NATIONALS', 'REGIONALS', 'WCC', 'WNL'),
                 allowNull: false
             },
             region: {

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

@@ -0,0 +1,19 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { MatchId, MatchModel } from '.';
+export interface MatchInputSnapshotAttributes {
+    match_id: string;
+    snapshot: object;
+}
+export type MatchInputSnapshotPk = 'match_id';
+export type MatchInputSnapshotId = MatchInputSnapshotModel[MatchInputSnapshotPk];
+export type MatchInputSnapshotCreationAttributes = MatchInputSnapshotAttributes;
+export declare class MatchInputSnapshotModel extends Model<MatchInputSnapshotAttributes, MatchInputSnapshotCreationAttributes> implements MatchInputSnapshotAttributes {
+    match_id: string;
+    snapshot: object;
+    Match: MatchModel;
+    getMatch: Sequelize.BelongsToGetAssociationMixin<MatchModel>;
+    setMatch: Sequelize.BelongsToSetAssociationMixin<MatchModel, MatchId>;
+    createMatch: Sequelize.BelongsToCreateAssociationMixin<MatchModel>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof MatchInputSnapshotModel;
+}

package/dist/cjs/src/data/models/match-input-snapshot.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MatchInputSnapshotModel = void 0;
+const sequelize_1 = require("sequelize");
+class MatchInputSnapshotModel extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return MatchInputSnapshotModel.init({
+            match_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'Match',
+                    key: 'match_id'
+                }
+            },
+            snapshot: {
+                type: sequelize_1.DataTypes.JSONB,
+                allowNull: false
+            }
+        }, {
+            sequelize,
+            tableName: 'MatchInputSnapshot',
+            schema: 'public',
+            timestamps: false,
+            indexes: [{
+                    name: 'MatchInputSnapshot_pk',
+                    unique: true,
+                    fields: [{ name: 'match_id' }]
+                }]
+        });
+    }
+}
+exports.MatchInputSnapshotModel = MatchInputSnapshotModel;

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

@@ -0,0 +1,21 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import { AuthUserId, AuthUserModel } from '.';
+export interface NationalTeamClaimAttributes {
+    country_id: string;
+    user_id: string;
+    claimed_at: Date;
+}
+export type NationalTeamClaimPk = 'country_id';
+export type NationalTeamClaimId = NationalTeamClaimModel[NationalTeamClaimPk];
+export type NationalTeamClaimOptionalAttributes = 'claimed_at';
+export type NationalTeamClaimCreationAttributes = Optional<NationalTeamClaimAttributes, NationalTeamClaimOptionalAttributes>;
+export declare class NationalTeamClaimModel extends Model<NationalTeamClaimAttributes, NationalTeamClaimCreationAttributes> implements NationalTeamClaimAttributes {
+    country_id: string;
+    user_id: string;
+    claimed_at: Date;
+    user: AuthUserModel;
+    getUser: Sequelize.BelongsToGetAssociationMixin<AuthUserModel>;
+    setUser: Sequelize.BelongsToSetAssociationMixin<AuthUserModel, AuthUserId>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof NationalTeamClaimModel;
+}

package/dist/cjs/src/data/models/national-team-claim.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NationalTeamClaimModel = void 0;
+const sequelize_1 = require("sequelize");
+class NationalTeamClaimModel extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return NationalTeamClaimModel.init({
+            country_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: { model: 'NationalTeam', key: 'country_id' }
+            },
+            user_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: { model: 'AuthUser', key: 'user_id' }
+            },
+            claimed_at: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: sequelize_1.DataTypes.NOW
+            }
+        }, {
+            sequelize,
+            tableName: 'NationalTeamClaim',
+            schema: 'public',
+            timestamps: false,
+            indexes: [
+                { name: 'NationalTeamClaim_pk', unique: true, fields: [{ name: 'country_id' }] },
+                { name: 'NationalTeamClaim_user_id_uq', unique: true, fields: [{ name: 'user_id' }] }
+            ]
+        });
+    }
+}
+exports.NationalTeamClaimModel = NationalTeamClaimModel;

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

@@ -0,0 +1,22 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { CountryId, CountryModel, TeamAttributes, TeamId, TeamModel } from '.';
+export interface NationalTeamAttributes {
+    country_id: string;
+    team_id: string;
+    team?: TeamAttributes;
+}
+export type NationalTeamPk = 'country_id';
+export type NationalTeamId = NationalTeamModel[NationalTeamPk];
+export type NationalTeamCreationAttributes = NationalTeamAttributes;
+export declare class NationalTeamModel extends Model<NationalTeamAttributes, NationalTeamCreationAttributes> implements NationalTeamAttributes {
+    country_id: string;
+    team_id: string;
+    country: CountryModel;
+    getCountry: Sequelize.BelongsToGetAssociationMixin<CountryModel>;
+    setCountry: Sequelize.BelongsToSetAssociationMixin<CountryModel, CountryId>;
+    team: TeamModel;
+    getTeam: Sequelize.BelongsToGetAssociationMixin<TeamModel>;
+    setTeam: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof NationalTeamModel;
+}

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NationalTeamModel = void 0;
+const sequelize_1 = require("sequelize");
+class NationalTeamModel extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return NationalTeamModel.init({
+            country_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: { model: 'Country', key: 'country_id' }
+            },
+            team_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: { model: 'Team', key: 'team_id' }
+            }
+        }, {
+            sequelize,
+            tableName: 'NationalTeam',
+            schema: 'public',
+            timestamps: false,
+            indexes: [
+                { name: 'NationalTeam_pk', unique: true, fields: [{ name: 'country_id' }] },
+                { name: 'NationalTeam_team_id_uq', unique: true, fields: [{ name: 'team_id' }] }
+            ]
+        });
+    }
+}
+exports.NationalTeamModel = NationalTeamModel;

package/dist/cjs/src/data/models/wnl-callup.d.ts

@@ -0,0 +1,31 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { CompetitionId, CompetitionModel, CountryId, CountryModel, PlayerId, PlayerModel } from '.';
+export type WnlCallupRole = 'SELECTION' | 'BACKUP';
+export interface WnlCallupAttributes {
+    competition_id: string;
+    player_id: string;
+    country_id: string;
+    role: WnlCallupRole;
+    slot_order: number;
+}
+export type WnlCallupPk = 'competition_id' | 'player_id';
+export type WnlCallupId = WnlCallupModel[WnlCallupPk];
+export type WnlCallupCreationAttributes = WnlCallupAttributes;
+export declare class WnlCallupModel extends Model<WnlCallupAttributes, WnlCallupCreationAttributes> implements WnlCallupAttributes {
+    competition_id: string;
+    player_id: string;
+    country_id: string;
+    role: WnlCallupRole;
+    slot_order: number;
+    competition: CompetitionModel;
+    getCompetition: Sequelize.BelongsToGetAssociationMixin<CompetitionModel>;
+    setCompetition: Sequelize.BelongsToSetAssociationMixin<CompetitionModel, CompetitionId>;
+    player: PlayerModel;
+    getPlayer: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
+    setPlayer: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;
+    country: CountryModel;
+    getCountry: Sequelize.BelongsToGetAssociationMixin<CountryModel>;
+    setCountry: Sequelize.BelongsToSetAssociationMixin<CountryModel, CountryId>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof WnlCallupModel;
+}

package/dist/cjs/src/data/models/wnl-callup.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WnlCallupModel = void 0;
+const sequelize_1 = require("sequelize");
+class WnlCallupModel extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return WnlCallupModel.init({
+            competition_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: { model: 'Competition', key: 'competition_id' }
+            },
+            player_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: { model: 'Player', key: 'player_id' }
+            },
+            country_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: { model: 'Country', key: 'country_id' }
+            },
+            role: {
+                type: sequelize_1.DataTypes.ENUM('SELECTION', 'BACKUP'),
+                allowNull: false
+            },
+            slot_order: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false
+            }
+        }, {
+            sequelize,
+            tableName: 'WnlCallup',
+            schema: 'public',
+            timestamps: false,
+            indexes: [
+                { name: 'WnlCallup_pk', unique: true, fields: [{ name: 'competition_id' }, { name: 'player_id' }] },
+                { name: 'WnlCallup_competition_country_idx', fields: [{ name: 'competition_id' }, { name: 'country_id' }] }
+            ]
+        });
+    }
+}
+exports.WnlCallupModel = WnlCallupModel;

package/dist/cjs/src/data/models/wnl-season.d.ts

@@ -0,0 +1,24 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import { CompetitionId, CompetitionModel } from '.';
+export interface WnlSeasonAttributes {
+    competition_id: string;
+    season_index: number;
+    finals_competition_id: string | null;
+}
+export type WnlSeasonPk = 'competition_id';
+export type WnlSeasonId = WnlSeasonModel[WnlSeasonPk];
+export type WnlSeasonOptionalAttributes = 'finals_competition_id';
+export type WnlSeasonCreationAttributes = Optional<WnlSeasonAttributes, WnlSeasonOptionalAttributes>;
+export declare class WnlSeasonModel extends Model<WnlSeasonAttributes, WnlSeasonCreationAttributes> implements WnlSeasonAttributes {
+    competition_id: string;
+    season_index: number;
+    finals_competition_id: string | null;
+    competition: CompetitionModel;
+    getCompetition: Sequelize.BelongsToGetAssociationMixin<CompetitionModel>;
+    setCompetition: Sequelize.BelongsToSetAssociationMixin<CompetitionModel, CompetitionId>;
+    finalsCompetition: CompetitionModel;
+    getFinalsCompetition: Sequelize.BelongsToGetAssociationMixin<CompetitionModel>;
+    setFinalsCompetition: Sequelize.BelongsToSetAssociationMixin<CompetitionModel, CompetitionId>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof WnlSeasonModel;
+}

package/dist/cjs/src/data/models/wnl-season.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WnlSeasonModel = void 0;
+const sequelize_1 = require("sequelize");
+class WnlSeasonModel extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return WnlSeasonModel.init({
+            competition_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: { model: 'Competition', key: 'competition_id' }
+            },
+            season_index: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false
+            },
+            finals_competition_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: true,
+                references: { model: 'Competition', key: 'competition_id' }
+            }
+        }, {
+            sequelize,
+            tableName: 'WnlSeason',
+            schema: 'public',
+            timestamps: false,
+            indexes: [
+                { name: 'WnlSeason_pk', unique: true, fields: [{ name: 'competition_id' }] }
+            ]
+        });
+    }
+}
+exports.WnlSeasonModel = WnlSeasonModel;

package/dist/cjs/src/data/models/wnl-squad.d.ts

@@ -0,0 +1,40 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import { AuthUserId, AuthUserModel, CompetitionId, CompetitionModel, CountryId, CountryModel, TeamId, TeamModel } from '.';
+export interface WnlSquadAttributes {
+    competition_id: string;
+    country_id: string;
+    team_id: string;
+    manager_user_id: string | null;
+    manager_name: string | null;
+    auto: boolean;
+    finalized: boolean;
+    finalized_at: Date | null;
+}
+export type WnlSquadPk = 'competition_id' | 'country_id';
+export type WnlSquadId = WnlSquadModel[WnlSquadPk];
+export type WnlSquadOptionalAttributes = 'manager_user_id' | 'manager_name' | 'auto' | 'finalized' | 'finalized_at';
+export type WnlSquadCreationAttributes = Optional<WnlSquadAttributes, WnlSquadOptionalAttributes>;
+export declare class WnlSquadModel extends Model<WnlSquadAttributes, WnlSquadCreationAttributes> implements WnlSquadAttributes {
+    competition_id: string;
+    country_id: string;
+    team_id: string;
+    manager_user_id: string | null;
+    manager_name: string | null;
+    auto: boolean;
+    finalized: boolean;
+    finalized_at: Date | null;
+    competition: CompetitionModel;
+    getCompetition: Sequelize.BelongsToGetAssociationMixin<CompetitionModel>;
+    setCompetition: Sequelize.BelongsToSetAssociationMixin<CompetitionModel, CompetitionId>;
+    country: CountryModel;
+    getCountry: Sequelize.BelongsToGetAssociationMixin<CountryModel>;
+    setCountry: Sequelize.BelongsToSetAssociationMixin<CountryModel, CountryId>;
+    team: TeamModel;
+    getTeam: Sequelize.BelongsToGetAssociationMixin<TeamModel>;
+    setTeam: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>;
+    manager: AuthUserModel;
+    getManager: Sequelize.BelongsToGetAssociationMixin<AuthUserModel>;
+    setManager: Sequelize.BelongsToSetAssociationMixin<AuthUserModel, AuthUserId>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof WnlSquadModel;
+}

package/dist/cjs/src/data/models/wnl-squad.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WnlSquadModel = void 0;
+const sequelize_1 = require("sequelize");
+class WnlSquadModel extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return WnlSquadModel.init({
+            competition_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: { model: 'Competition', key: 'competition_id' }
+            },
+            country_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: { model: 'Country', key: 'country_id' }
+            },
+            team_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: { model: 'Team', key: 'team_id' }
+            },
+            manager_user_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: true,
+                references: { model: 'AuthUser', key: 'user_id' }
+            },
+            manager_name: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: true
+            },
+            auto: {
+                type: sequelize_1.DataTypes.BOOLEAN,
+                allowNull: false,
+                defaultValue: false
+            },
+            finalized: {
+                type: sequelize_1.DataTypes.BOOLEAN,
+                allowNull: false,
+                defaultValue: false
+            },
+            finalized_at: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: true
+            }
+        }, {
+            sequelize,
+            tableName: 'WnlSquad',
+            schema: 'public',
+            timestamps: false,
+            indexes: [
+                { name: 'WnlSquad_pk', unique: true, fields: [{ name: 'competition_id' }, { name: 'country_id' }] }
+            ]
+        });
+    }
+}
+exports.WnlSquadModel = WnlSquadModel;

package/dist/cjs/src/service/match/index.d.ts

@@ -1,6 +1,7 @@
 export * from './box-score';
 export * from './match';
 export * from './match-generator';
+export { default as MatchGenerator } from './match-generator';
 export * from './match-rating';
 export * from './match-set';
 export * from './rally';

package/dist/cjs/src/service/match/index.js

@@ -13,10 +13,18 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.MatchGenerator = void 0;
 __exportStar(require("./box-score"), exports);
 __exportStar(require("./match"), exports);
 __exportStar(require("./match-generator"), exports);
+// The default export (the class itself) is not surfaced by `export *`; re-export it by name so consumers (e.g. the
+// engine's WNL scheduler) can call MatchGenerator.generateMatches with custom spacing/start-hour options.
+var match_generator_1 = require("./match-generator");
+Object.defineProperty(exports, "MatchGenerator", { enumerable: true, get: function () { return __importDefault(match_generator_1).default; } });
 __exportStar(require("./match-rating"), exports);
 __exportStar(require("./match-set"), exports);
 __exportStar(require("./rally"), exports);

package/dist/cjs/src/service/match/match-generator.d.ts

@@ -1,5 +1,9 @@
 import { Team } from '../team';
 import { Match } from './match';
+export interface GenerateMatchesOptions {
+    spacingMinutes?: number;
+    startHourUTC?: number;
+}
 export default class MatchGenerator {
-    static generateMatches(teams: Team[], baseDate: Date): Match[];
+    static generateMatches(teams: Team[], baseDate: Date, options?: GenerateMatchesOptions): Match[];
 }