@mtgame/core 0.1.128 → 0.1.130

package/bundles/mtgame-core.umd.js

@@ -1802,6 +1802,7 @@
                 season: 'season',
                 season_id: 'seasonId',
                 game_price: 'gamePrice',
+                season_tournament_id: 'seasonTournamentId',
             },
             relation: {
                 logo: exports.File,
@@ -1932,7 +1933,8 @@
                 id: 'id',
                 name: 'name',
                 address: 'address',
-                league_id: 'leagueId'
+                league_id: 'leagueId',
+                active_games_count: 'activeGamesCount',
             }
         })
     ], exports.LeagueCourt);
@@ -2125,7 +2127,7 @@
     ], exports.HandballGameConfig);
 
     function generateArray(length) {
-        if (length <= 0) {
+        if (+length <= 0) {
             return [];
         }
         return Array.apply(null, Array(length)).map(function (_, i) { return i + 1; });
@@ -2231,7 +2233,9 @@
                 settings: 'settings',
                 tournament_id: 'tournamentId',
                 tournament_stage_id: 'tournamentStageId',
-                is_official: 'isOfficial'
+                is_official: 'isOfficial',
+                tournament_round_id: 'tournamentRoundId',
+                division_id: 'divisionId',
             },
             relation: {
                 settings: exports.PlayoffSettings
@@ -2260,7 +2264,9 @@
                 id: 'id',
                 name: 'name',
                 sort: 'sort',
-                tournament_stage_id: 'tournamentStageId'
+                tournament_stage_id: 'tournamentStageId',
+                tournament_round_id: 'tournamentRoundId',
+                division_id: 'divisionId',
             }
         })
     ], exports.TournamentGroup);
@@ -2384,6 +2390,7 @@
         GameResultTypes[GameResultTypes["competitor_team_won"] = 2] = "competitor_team_won";
         GameResultTypes[GameResultTypes["team_technical_defeat"] = 3] = "team_technical_defeat";
         GameResultTypes[GameResultTypes["competitor_team_technical_defeat"] = 4] = "competitor_team_technical_defeat";
+        GameResultTypes[GameResultTypes["draw"] = 5] = "draw";
     })(exports.GameResultTypes || (exports.GameResultTypes = {}));
     exports.TournamentTeamShort = /** @class */ (function (_super) {
         __extends(TournamentTeamShort, _super);
@@ -2581,6 +2588,22 @@
             enumerable: false,
             configurable: true
         });
+        Object.defineProperty(Game.prototype, "teamLoserId", {
+            get: function () {
+                if (!this.isClosed) {
+                    return null;
+                }
+                if (this.isTeamWon) {
+                    return this.competitorTeam.id || this.competitorTeamId;
+                }
+                if (this.isCompetitorTeamWon) {
+                    return this.team.id || this.teamId;
+                }
+                return null;
+            },
+            enumerable: false,
+            configurable: true
+        });
         Game.toFront = function (data) { };
         Game.toBack = function (data) { };
         return Game;
@@ -2741,8 +2764,8 @@
             this.engine = engine;
             this.data = {};
         }
-        Store.prototype.get = function (key) {
-            return this.getSubject(key).pipe(operators.filter(function (item) { return item !== undefined; }));
+        Store.prototype.get = function (key, defaultValue) {
+            return this.getSubject(key).pipe(operators.map(function (item) { return item === undefined ? defaultValue : item; }), operators.filter(function (item) { return item !== undefined; }));
         };
         Store.prototype.value = function (key, defaultValue) {
             return this.getSubject(key).value === undefined ? defaultValue : this.getSubject(key).value;
@@ -2868,6 +2891,34 @@
         { type: undefined, decorators: [{ type: i0.Optional }, { type: i0.Inject, args: [CONFIG_DATA,] }] }
     ]; };
 
+    exports.TournamentDivision = /** @class */ (function (_super) {
+        __extends(TournamentDivision, _super);
+        function TournamentDivision() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        TournamentDivision.toFront = function (data) { };
+        TournamentDivision.toBack = function (data) { };
+        return TournamentDivision;
+    }(BaseModel));
+    __decorate([
+        ToFrontHook
+    ], exports.TournamentDivision, "toFront", null);
+    __decorate([
+        ToBackHook
+    ], exports.TournamentDivision, "toBack", null);
+    exports.TournamentDivision = __decorate([
+        ModelInstance({
+            mappingFields: {
+                id: 'id',
+                name: 'name',
+                cover: 'cover',
+            },
+            relation: {
+                cover: exports.File
+            }
+        })
+    ], exports.TournamentDivision);
+
     exports.TournamentTeam = /** @class */ (function (_super) {
         __extends(TournamentTeam, _super);
         function TournamentTeam() {
@@ -2904,6 +2955,7 @@
                 tournament: 'tournament',
                 team: 'team',
                 group: 'group',
+                division: 'division',
                 final_standing: 'finalStanding',
                 games_count: 'gamesCount',
                 won_games_count: 'wonGamesCount',
@@ -2937,6 +2989,7 @@
                 group: exports.TournamentGroup,
                 games: exports.Game,
                 lastFiveGames: exports.Game,
+                division: exports.TournamentDivision,
             }
         })
     ], exports.TournamentTeam);
@@ -3235,6 +3288,9 @@
                 win_lose: 'winLose',
                 games_count: 'gamesCount',
                 won_games_count: 'wonGamesCount',
+                team_score_sum: 'teamScoreSum',
+                team_missed_sum: 'teamMissedSum',
+                tournament_points: 'tournamentPoints',
                 points: 'points',
                 two_points_made: 'twoPointsMade',
                 three_points_made: 'threePointsMade',
@@ -3633,6 +3689,7 @@
                 team_user: 'teamUser',
                 tournament_team_user: 'tournamentTeamUser',
                 is_mvp: 'isMvp',
+                number: 'number',
                 updated_at: 'updatedAt'
             },
             relation: {
@@ -4422,6 +4479,9 @@
                 games_count: 'gamesCount',
                 won_games_count: 'wonGamesCount',
                 lose_games_count: 'loseGamesCount',
+                team_score_sum: 'teamScoreSum',
+                team_missed_sum: 'teamMissedSum',
+                tournament_points: 'tournamentPoints',
                 points: 'points',
                 pp_shots: 'ppShots',
                 pp_shot_misses: 'ppShotMisses',
@@ -4915,6 +4975,13 @@
         function FootballStatistic() {
             return _super !== null && _super.apply(this, arguments) || this;
         }
+        Object.defineProperty(FootballStatistic.prototype, "teamPlusMinus", {
+            get: function () {
+                return (this.teamScoreSum || 0) - (this.teamMissedSum || 0);
+            },
+            enumerable: false,
+            configurable: true
+        });
         Object.defineProperty(FootballStatistic.prototype, "userMinutes", {
             get: function () {
                 if (!this.gameTime) {
@@ -5033,6 +5100,11 @@
                 win_lose: 'winLose',
                 games_count: 'gamesCount',
                 won_games_count: 'wonGamesCount',
+                lose_games_count: 'loseGamesCount',
+                draw_games_count: 'drawGamesCount',
+                team_score_sum: 'teamScoreSum',
+                team_missed_sum: 'teamMissedSum',
+                tournament_points: 'tournamentPoints',
                 points: 'points',
                 shot_misses: 'shotMisses',
                 shots_on_goal: 'shotsOnGoal',
@@ -5493,6 +5565,9 @@
                 win_lose: 'winLose',
                 games_count: 'gamesCount',
                 won_games_count: 'wonGamesCount',
+                team_score_sum: 'teamScoreSum',
+                team_missed_sum: 'teamMissedSum',
+                tournament_points: 'tournamentPoints',
                 points: 'points',
                 shot_misses: 'shotMisses',
                 shots_on_goal: 'shotsOnGoal',
@@ -5719,6 +5794,7 @@
                 current_playoff_round: 'currentPlayoffRound',
                 stages: 'stages',
                 tournament_stage_id: 'tournamentStageId',
+                tournament_round_id: 'tournamentRoundId',
             },
             relation: {
                 stages: listField(exports.GameTimelineStageItem)
@@ -5833,6 +5909,9 @@
                 win_lose: 'winLose',
                 games_count: 'gamesCount',
                 won_games_count: 'wonGamesCount',
+                team_score_sum: 'teamScoreSum',
+                team_missed_sum: 'teamMissedSum',
+                tournament_points: 'tournamentPoints',
                 serve_hits: 'serveHits',
                 serve_faults: 'serveFaults',
                 serve_aces: 'serveAces',
@@ -6110,6 +6189,7 @@
     exports.RugbyStatistic = __decorate([
         ModelInstance({
             mappingFields: {
+                league_player: 'leaguePlayer',
                 tournament_team_user: 'tournamentTeamUser',
                 team: 'team',
                 team_user: 'teamUser',
@@ -6121,6 +6201,9 @@
                 won_games_count: 'wonGamesCount',
                 lose_games_count: 'loseGamesCount',
                 draw_games_count: 'drawGamesCount',
+                team_score_sum: 'teamScoreSum',
+                team_missed_sum: 'teamMissedSum',
+                tournament_points: 'tournamentPoints',
                 newbie: 'newbie',
                 // User statistic
                 points: 'points',
@@ -6185,6 +6268,7 @@
                 team_fouls: 'teamFouls',
             },
             relation: {
+                leaguePlayer: exports.LeaguePlayer,
                 tournamentTeamUser: exports.TournamentTeamUser,
                 team: exports.Team,
                 teamUser: exports.TeamUser,
@@ -6347,6 +6431,9 @@
                 games_count: 'gamesCount',
                 won_games_count: 'wonGamesCount',
                 lose_games_count: 'loseGamesCount',
+                team_score_sum: 'teamScoreSum',
+                team_missed_sum: 'teamMissedSum',
+                tournament_points: 'tournamentPoints',
                 points: 'points',
                 pp_shots: 'ppShots',
                 pp_shot_misses: 'ppShotMisses',
@@ -6453,6 +6540,48 @@
         })
     ], exports.WaterpoloStatistic);
 
+    exports.TournamentRoundTypes = void 0;
+    (function (TournamentRoundTypes) {
+        TournamentRoundTypes[TournamentRoundTypes["group"] = 1] = "group";
+        TournamentRoundTypes[TournamentRoundTypes["playoff"] = 2] = "playoff";
+    })(exports.TournamentRoundTypes || (exports.TournamentRoundTypes = {}));
+    var TournamentRoundSettings = /** @class */ (function (_super) {
+        __extends(TournamentRoundSettings, _super);
+        function TournamentRoundSettings() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        return TournamentRoundSettings;
+    }(BaseModel));
+    exports.TournamentRound = /** @class */ (function (_super) {
+        __extends(TournamentRound, _super);
+        function TournamentRound() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        TournamentRound.toFront = function (data) { };
+        TournamentRound.toBack = function (data) { };
+        return TournamentRound;
+    }(BaseModel));
+    __decorate([
+        ToFrontHook
+    ], exports.TournamentRound, "toFront", null);
+    __decorate([
+        ToBackHook
+    ], exports.TournamentRound, "toBack", null);
+    exports.TournamentRound = __decorate([
+        ModelInstance({
+            mappingFields: {
+                id: 'id',
+                name: 'name',
+                type: 'type',
+                divisions: 'divisions',
+            },
+            relation: {
+                type: enumField(exports.TournamentRoundTypes),
+                divisions: listField(exports.TournamentDivision),
+            }
+        })
+    ], exports.TournamentRound);
+
     var TournamentApi = /** @class */ (function () {
         function TournamentApi(httpClient, configService) {
             this.httpClient = httpClient;
@@ -6476,6 +6605,15 @@
                 });
             });
         };
+        TournamentApi.prototype.getSeasonTournaments = function (seasonTournamentId) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/season_tournament/" + seasonTournamentId + "/tournaments/")
+                            .pipe(operators.map(function (result) { return exports.Tournament.toFront(result); }))
+                            .toPromise()];
+                });
+            });
+        };
         TournamentApi.prototype.getNews = function (tournamentId) {
             return __awaiter(this, void 0, void 0, function () {
                 return __generator(this, function (_a) {
@@ -6518,6 +6656,20 @@
                 });
             });
         };
+        TournamentApi.prototype.getTournamentRounds = function (tournamentId) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament/" + tournamentId + "/rounds/").pipe(operators.map(function (data) { return exports.TournamentRound.toFront(data); })).toPromise()];
+                });
+            });
+        };
+        TournamentApi.prototype.getTournamentDivisions = function (tournamentId) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament/" + tournamentId + "/divisions/").pipe(operators.map(function (data) { return exports.TournamentDivision.toFront(data); })).toPromise()];
+                });
+            });
+        };
         TournamentApi.prototype.getPlayoff = function (tournamentId) {
             return __awaiter(this, void 0, void 0, function () {
                 return __generator(this, function (_a) {
@@ -6537,10 +6689,15 @@
                 });
             });
         };
-        TournamentApi.prototype.getGamesStages = function (tournamentId) {
+        TournamentApi.prototype.getGamesStages = function (tournamentId, roundId) {
             return __awaiter(this, void 0, void 0, function () {
+                var params;
                 return __generator(this, function (_a) {
-                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament/" + tournamentId + "/games_stages/")
+                    params = new i1.HttpParams();
+                    if (roundId) {
+                        params = params.set('tournament_round_id', roundId.toString());
+                    }
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament/" + tournamentId + "/games_stages/", { params: params })
                             .pipe(operators.map(function (data) { return exports.GameTimelineStages.toFront(data); }))
                             .toPromise()];
                 });
@@ -6583,7 +6740,7 @@
                 });
             });
         };
-        TournamentApi.prototype.getTeams = function (tournamentId, groupId) {
+        TournamentApi.prototype.getTeams = function (tournamentId, groupId, short) {
             return __awaiter(this, void 0, void 0, function () {
                 var params;
                 return __generator(this, function (_a) {
@@ -6591,6 +6748,9 @@
                     if (groupId) {
                         params = params.set('group_id', groupId.toString());
                     }
+                    if (short) {
+                        params = params.set('short', '1');
+                    }
                     return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament/" + tournamentId + "/teams/", { params: params })
                             .pipe(operators.map(function (result) { return exports.TournamentTeam.toFront(result); }))
                             .toPromise()];
@@ -6949,6 +7109,12 @@
         if (filters.tournamentStageId) {
             params = params.set('tournament_stage_id', filters.tournamentStageId.toString());
         }
+        if (filters.tournamentRoundId) {
+            params = params.set('tournament_round_id', filters.tournamentRoundId.toString());
+        }
+        if (filters.divisionId) {
+            params = params.set('division_id', filters.divisionId.toString());
+        }
         if (filters.tournamentTour) {
             params = params.set('tournament_tour', filters.tournamentTour.toString());
         }
@@ -7175,6 +7341,30 @@
         })
     ], exports.TeamsAndUsers);
 
+    var SeasonTournament = /** @class */ (function (_super) {
+        __extends(SeasonTournament, _super);
+        function SeasonTournament() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        SeasonTournament.toFront = function (data) { };
+        SeasonTournament.toBack = function (data) { };
+        return SeasonTournament;
+    }(BaseModel));
+    __decorate([
+        ToFrontHook
+    ], SeasonTournament, "toFront", null);
+    __decorate([
+        ToBackHook
+    ], SeasonTournament, "toBack", null);
+    SeasonTournament = __decorate([
+        ModelInstance({
+            mappingFields: {
+                id: 'id',
+                name: 'name',
+            },
+        })
+    ], SeasonTournament);
+
     var LeagueApi = /** @class */ (function () {
         function LeagueApi(httpClient, configService) {
             this.httpClient = httpClient;
@@ -7194,6 +7384,13 @@
                 });
             });
         };
+        LeagueApi.prototype.getSeasonTournaments = function (leagueId) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/league/" + leagueId + "/season_tournaments/").pipe(operators.map(function (response) { return SeasonTournament.toFront(response); })).toPromise()];
+                });
+            });
+        };
         LeagueApi.prototype.getTournaments = function (leagueId, filters) {
             return __awaiter(this, void 0, void 0, function () {
                 var params;
@@ -9510,6 +9707,177 @@
         { type: ConfigService }
     ]; };
 
+    exports.RoundTeamGame = /** @class */ (function (_super) {
+        __extends(RoundTeamGame, _super);
+        function RoundTeamGame() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        RoundTeamGame.toFront = function (data) { };
+        RoundTeamGame.toBack = function (data) { };
+        return RoundTeamGame;
+    }(BaseModel));
+    __decorate([
+        ToFrontHook
+    ], exports.RoundTeamGame, "toFront", null);
+    __decorate([
+        ToBackHook
+    ], exports.RoundTeamGame, "toBack", null);
+    exports.RoundTeamGame = __decorate([
+        ModelInstance({
+            mappingFields: {
+                id: 'id',
+                team_id: 'teamId',
+                competitor_team_id: 'competitorTeamId',
+                team_score: 'teamScore',
+                competitor_team_score: 'competitorTeamScore',
+            }
+        })
+    ], exports.RoundTeamGame);
+    exports.TournamentRoundTeam = /** @class */ (function (_super) {
+        __extends(TournamentRoundTeam, _super);
+        function TournamentRoundTeam() {
+            var _this = _super.apply(this, __spreadArray([], __read(arguments))) || this;
+            _this.gamesMapping = {};
+            return _this;
+        }
+        Object.defineProperty(TournamentRoundTeam.prototype, "games", {
+            get: function () {
+                return this._games;
+            },
+            set: function (value) {
+                var _this = this;
+                this._games = value;
+                this.gamesMapping = value.reduce(function (acc, game) {
+                    var _a;
+                    var competitorTeamId = game.teamId === _this.tournamentTeam.team.id ? game.competitorTeamId : game.teamId;
+                    return Object.assign(Object.assign({}, acc), (_a = {}, _a[competitorTeamId] = __spreadArray(__spreadArray([], __read((acc[competitorTeamId] || []))), [
+                        game,
+                    ]), _a));
+                }, {});
+            },
+            enumerable: false,
+            configurable: true
+        });
+        TournamentRoundTeam.toFront = function (data) { };
+        TournamentRoundTeam.toBack = function (data) { };
+        return TournamentRoundTeam;
+    }(BaseModel));
+    __decorate([
+        ToFrontHook
+    ], exports.TournamentRoundTeam, "toFront", null);
+    __decorate([
+        ToBackHook
+    ], exports.TournamentRoundTeam, "toBack", null);
+    exports.TournamentRoundTeam = __decorate([
+        ModelInstance({
+            mappingFields: {
+                id: 'id',
+                tournament_team: 'tournamentTeam',
+                group: 'group',
+                division: 'division',
+                points: 'points',
+                handicap: 'handicap',
+                games_count: 'gamesCount',
+                won_games_count: 'wonGamesCount',
+                lose_games_count: 'loseGamesCount',
+                draw_games_count: 'drawGamesCount',
+                score_sum: 'scoreSum',
+                missed_sum: 'missedSum',
+                games_won_percent: 'gamesWonPercent',
+                score_points_sum: 'scorePointsSum',
+                missed_points_sum: 'missedPointsSum',
+                win_normal_time_games_count: 'winNormalTimeGamesCount',
+                lose_normal_time_games_count: 'loseNormalTimeGamesCount',
+                win_overtime_games_count: 'winOvertimeGamesCount',
+                lose_overtime_games_count: 'loseOvertimeGamesCount',
+                last_games_won: 'lastGamesWon',
+                last_games_count: 'lastGamesCount',
+                tries_scored: 'triesScored',
+                tries_missed: 'triesMissed',
+                attack_bonuses: 'attackBonuses',
+                defense_bonuses: 'defenseBonuses',
+                games_by_score_count: 'gamesByScoreCount',
+                games: 'games',
+            },
+            relation: {
+                group: exports.TournamentGroup,
+                division: exports.TournamentDivision,
+                tournamentTeam: exports.TournamentTeam,
+                games: listField(exports.RoundTeamGame),
+            }
+        })
+    ], exports.TournamentRoundTeam);
+
+    var TournamentRoundApi = /** @class */ (function () {
+        function TournamentRoundApi(httpClient, configService) {
+            this.httpClient = httpClient;
+            this.configService = configService;
+        }
+        TournamentRoundApi.prototype.getById = function (tournamentRoundId) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament_round/" + tournamentRoundId + "/").pipe(operators.map(function (data) { return exports.TournamentRound.toFront(data); })).toPromise()];
+                });
+            });
+        };
+        TournamentRoundApi.prototype.getTeams = function (tournamentRoundId, filters) {
+            return __awaiter(this, void 0, void 0, function () {
+                var params;
+                return __generator(this, function (_a) {
+                    params = new i1.HttpParams();
+                    if (filters) {
+                        if (filters.divisionId) {
+                            params = params.set('division_id', filters.divisionId);
+                        }
+                        if (filters.groupId) {
+                            params = params.set('group_id', filters.groupId);
+                        }
+                    }
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament_round/" + tournamentRoundId + "/teams/", { params: params }).pipe(operators.map(function (data) { return exports.TournamentRoundTeam.toFront(data); })).toPromise()];
+                });
+            });
+        };
+        TournamentRoundApi.prototype.getPlayoffs = function (tournamentRoundId) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament_round/" + tournamentRoundId + "/playoffs/").pipe(operators.map(function (data) { return exports.Playoff.toFront(data); })).toPromise()];
+                });
+            });
+        };
+        TournamentRoundApi.prototype.getGroups = function (tournamentRoundId) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament_round/" + tournamentRoundId + "/groups/").pipe(operators.map(function (data) { return exports.TournamentGroup.toFront(data); })).toPromise()];
+                });
+            });
+        };
+        TournamentRoundApi.prototype.getGames = function (roundId, page, size, filters) {
+            return __awaiter(this, void 0, void 0, function () {
+                var params;
+                return __generator(this, function (_a) {
+                    params = new i1.HttpParams().set('page', page.toString());
+                    if (size) {
+                        params = params.set('size', size.toString());
+                    }
+                    params = applyGamesFilters(filters, params);
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament_round/" + roundId + "/games/", { params: params, observe: 'response' }).pipe(operators.map(function (result) { return ({
+                            total: +result.headers.get('X-Page-Count'),
+                            data: exports.Game.toFront(result.body)
+                        }); })).toPromise()];
+                });
+            });
+        };
+        return TournamentRoundApi;
+    }());
+    TournamentRoundApi.ɵprov = i0__namespace.ɵɵdefineInjectable({ factory: function TournamentRoundApi_Factory() { return new TournamentRoundApi(i0__namespace.ɵɵinject(i1__namespace.HttpClient), i0__namespace.ɵɵinject(ConfigService)); }, token: TournamentRoundApi, providedIn: "root" });
+    TournamentRoundApi.decorators = [
+        { type: i0.Injectable, args: [{ providedIn: 'root' },] }
+    ];
+    TournamentRoundApi.ctorParameters = function () { return [
+        { type: i1.HttpClient },
+        { type: ConfigService }
+    ]; };
+
     var TournamentSeasonApi = /** @class */ (function () {
         function TournamentSeasonApi(httpClient, configService) {
             this.httpClient = httpClient;
@@ -12189,6 +12557,8 @@
     exports.ToFrontHook = ToFrontHook;
     exports.TournamentApi = TournamentApi;
     exports.TournamentJoinApi = TournamentJoinApi;
+    exports.TournamentRoundApi = TournamentRoundApi;
+    exports.TournamentRoundSettings = TournamentRoundSettings;
     exports.TournamentSeasonApi = TournamentSeasonApi;
     exports.TournamentStageApi = TournamentStageApi;
     exports.UntilDestroy = UntilDestroy;