@mtgame/core 0.1.113 → 0.1.115

package/fesm2015/mtgame-core.js

@@ -369,6 +369,9 @@ var SportTypes;
     SportTypes[SportTypes["rugby7"] = 16] = "rugby7";
     SportTypes[SportTypes["rugby15"] = 17] = "rugby15";
     SportTypes[SportTypes["basketball_1x1"] = 18] = "basketball_1x1";
+    SportTypes[SportTypes["waterpolo"] = 19] = "waterpolo";
+    SportTypes[SportTypes["classic_waterpolo"] = 20] = "classic_waterpolo";
+    SportTypes[SportTypes["mini_waterpolo"] = 21] = "mini_waterpolo";
 })(SportTypes || (SportTypes = {}));
 let Sport = class Sport extends BaseModel {
     isBasketball() {
@@ -425,6 +428,15 @@ let Sport = class Sport extends BaseModel {
     isRugby7() {
         return this.id === SportTypes.rugby7;
     }
+    isWaterpolo() {
+        return this.id === SportTypes.waterpolo || this.parentId === SportTypes.waterpolo;
+    }
+    isClassicWaterpolo() {
+        return this.id === SportTypes.classic_waterpolo;
+    }
+    isMiniWaterpolo() {
+        return this.id === SportTypes.mini_waterpolo;
+    }
     static toFront(data) {
         return null;
     }
@@ -716,6 +728,45 @@ RugbyProfile = __decorate([
     })
 ], RugbyProfile);
 
+var GameWaterpoloPosition;
+(function (GameWaterpoloPosition) {
+    GameWaterpoloPosition[GameWaterpoloPosition["goalkeeper"] = 1] = "goalkeeper";
+    GameWaterpoloPosition[GameWaterpoloPosition["defensemen"] = 2] = "defensemen";
+    GameWaterpoloPosition[GameWaterpoloPosition["center_forward"] = 3] = "center_forward";
+    GameWaterpoloPosition[GameWaterpoloPosition["mobile_forward"] = 4] = "mobile_forward";
+})(GameWaterpoloPosition || (GameWaterpoloPosition = {}));
+var WaterpoloWorkHand;
+(function (WaterpoloWorkHand) {
+    WaterpoloWorkHand[WaterpoloWorkHand["left"] = 1] = "left";
+    WaterpoloWorkHand[WaterpoloWorkHand["right"] = 2] = "right";
+})(WaterpoloWorkHand || (WaterpoloWorkHand = {}));
+let WaterpoloProfile = class WaterpoloProfile extends BaseModel {
+    static toFront(value) {
+    }
+    static toBack(value) {
+    }
+};
+__decorate([
+    ToFrontHook
+], WaterpoloProfile, "toFront", null);
+__decorate([
+    ToBackHook
+], WaterpoloProfile, "toBack", null);
+WaterpoloProfile = __decorate([
+    ModelInstance({
+        mappingFields: {
+            id: 'id',
+            user_id: 'userId',
+            position: 'position',
+            work_hand: 'workHand'
+        },
+        relation: {
+            position: enumField(GameWaterpoloPosition),
+            workHand: enumField(WaterpoloWorkHand)
+        }
+    })
+], WaterpoloProfile);
+
 var UserGender;
 (function (UserGender) {
     UserGender[UserGender["male"] = 1] = "male";
@@ -769,6 +820,7 @@ User = __decorate([
             football_profile: 'footballProfile',
             handball_profile: 'handballProfile',
             rugby_profile: 'rugbyProfile',
+            wateprolo_profile: 'waterpoloProfile',
             wizards: 'wizards',
             city: 'city',
             gender: 'gender',
@@ -784,6 +836,7 @@ User = __decorate([
             footballProfile: FootballProfile,
             handballProfile: HandballProfile,
             rugbyProfile: RugbyProfile,
+            waterpoloProfile: WaterpoloProfile,
             city: City,
             gender: enumField(UserGender)
         }
@@ -808,6 +861,12 @@ let Team = class Team extends BaseModel {
         if (this.sport.isHandball()) {
             classList.push('empty-logo-handball');
         }
+        if (this.sport.isRugby()) {
+            classList.push('empty-logo-rugby');
+        }
+        if (this.sport.isWaterpolo()) {
+            classList.push('empty-logo-waterpolo');
+        }
         return classList.join(' ');
     }
     static toFront(data) {
@@ -1156,6 +1215,15 @@ let Tournament = class Tournament extends BaseModel {
         if (this.sport.isFootball()) {
             classList.push('empty-logo-football');
         }
+        if (this.sport.isHandball()) {
+            classList.push('empty-logo-handball');
+        }
+        if (this.sport.isRugby()) {
+            classList.push('empty-logo-rugby');
+        }
+        if (this.sport.isWaterpolo()) {
+            classList.push('empty-logo-waterpolo');
+        }
         return classList.join(' ');
     }
     static toFront(data) { }
@@ -1618,6 +1686,46 @@ RugbyGameConfig = __decorate([
     })
 ], RugbyGameConfig);
 
+let WaterpoloGameConfig = class WaterpoloGameConfig extends BaseModel {
+    static toFront(data) { }
+    static toBack(data) { }
+    get overtimePeriod() {
+        return this.periodsCount + 1;
+    }
+    get bullitsPeriod() {
+        return this.periodsCount + 2;
+    }
+    get playoffBullitsPeriod() {
+        return this.periodsCount + 3;
+    }
+};
+__decorate([
+    ToFrontHook
+], WaterpoloGameConfig, "toFront", null);
+__decorate([
+    ToBackHook
+], WaterpoloGameConfig, "toBack", null);
+WaterpoloGameConfig = __decorate([
+    ModelInstance({
+        mappingFields: {
+            periods_count: 'periodsCount',
+            period_time: 'periodTime',
+            overtime_type: 'overtimeType',
+            overtime_time: 'overtimeTime',
+            max_game_players: 'maxGamePlayers',
+            timeout_count: 'timeoutCount',
+            overtime_timeout_count: 'overtimeTimeoutCount',
+            timeout_time: 'timeoutTime',
+            game_time_type: 'gameTimeType',
+            substitute_manage_enabled: 'substituteManageEnabled',
+        },
+        relation: {
+            overtimeType: enumField(OvertimeTypes),
+            gameTimeType: enumField(GameTimeTypes),
+        }
+    })
+], WaterpoloGameConfig);
+
 var GameStatuses;
 (function (GameStatuses) {
     GameStatuses[GameStatuses["open"] = 1] = "open";
@@ -1728,6 +1836,18 @@ let Game = class Game extends BaseModel {
     set rugbyGameConfig(value) {
         this._rugbyGameConfig = value;
     }
+    get waterpoloGameConfig() {
+        if (this._waterpoloGameConfig && this._waterpoloGameConfig.periodsCount) {
+            return this._waterpoloGameConfig;
+        }
+        if (this.gameConfig) {
+            this._waterpoloGameConfig = WaterpoloGameConfig.toFront(this.gameConfig);
+        }
+        return this._waterpoloGameConfig;
+    }
+    set waterpoloGameConfig(value) {
+        this._waterpoloGameConfig = value;
+    }
     get scoreByPeriodList() {
         if (!this.scoreByPeriod) {
             return [];
@@ -1797,6 +1917,7 @@ Game = __decorate([
             football_game_config: 'footballGameConfig',
             handball_game_config: 'handballGameConfig',
             rugby_game_config: 'rugbyGameConfig',
+            waterpolo_game_config: 'waterpoloGameConfig',
             score_by_period: 'scoreByPeriod',
             playoff_stage: 'playoffStage',
             playoff_round: 'playoffRound',
@@ -1823,6 +1944,8 @@ Game = __decorate([
             hockeyGameConfig: HockeyGameConfig,
             footballGameConfig: FootballGameConfig,
             handballGameConfig: HandballGameConfig,
+            rugbyGameConfig: RugbyGameConfig,
+            waterpoloGameConfig: WaterpoloGameConfig,
             tournamentPlayoff: Playoff,
             tournamentCourt: LeagueCourt,
             media: listField(MediaItem),
@@ -2324,6 +2447,7 @@ BasketballStatistic = __decorate([
             disqualification_fouls: 'disqualificationFouls',
             drawn_fouls: 'drawnFouls',
             player_efficiency: 'playerEfficiency',
+            shots_blocked: 'shotsBlocked',
             game_time: 'gameTime',
             newbie: 'newbie',
             rank: 'rank',
@@ -2432,6 +2556,7 @@ BasketballGameStatistic = __decorate([
             disqualification_fouls: 'disqualificationFouls',
             drawn_fouls: 'drawnFouls',
             player_efficiency: 'playerEfficiency',
+            shots_blocked: 'shotsBlocked',
             updated_at: 'updatedAt',
         },
         relation: {
@@ -3120,6 +3245,9 @@ let HockeyGameStatistic = class HockeyGameStatistic extends BaseModel {
         }
         return Math.round(1000 * this.faceOffWins / this.faceOffs) / 10;
     }
+    get goalpass() {
+        return (this.totalGoals || 0) + (this.assists || 0);
+    }
     static toFront(data) { }
     static toBack(data) { }
 };
@@ -3178,6 +3306,9 @@ let HockeyStatistic = class HockeyStatistic extends BaseModel {
     get assists() {
         return (this.ppAssists || 0) + (this.shAssists || 0) + (this.evAssists || 0);
     }
+    get goalpass() {
+        return (this.totalGoals || 0) + (this.assists || 0);
+    }
     get userMinutes() {
         if (!this.gameTime) {
             return '00:00';
@@ -3537,6 +3668,9 @@ let FootballGameStatistic = class FootballGameStatistic extends BaseModel {
         }
         return Math.round(1000 * this.smallPenaltySaves / this.smallPenaltyShotsAgainst) / 10;
     }
+    get goalpass() {
+        return (this.totalGoals || 0) + (this.assists || 0);
+    }
     get gameMinutes() {
         return Math.floor(this.gameTime / 60);
     }
@@ -3610,6 +3744,9 @@ let FootballStatistic = class FootballStatistic extends BaseModel {
     get smallPenalties() {
         return Math.floor(10 * ((this.smallPenaltyGoals || 0) + (this.smallPenaltyAttempts || 0))) / 10;
     }
+    get goalpass() {
+        return (this.totalGoals || 0) + (this.assists || 0);
+    }
     get tournamentTeamPoints() {
         return this.tournamentTeam && this.tournamentTeam.points;
     }
@@ -4666,6 +4803,130 @@ TeamAchievement = __decorate([
     })
 ], TeamAchievement);
 
+let WaterpoloStatistic = class WaterpoloStatistic extends BaseModel {
+    get assists() {
+        return (this.ppAssists || 0) + (this.shAssists || 0) + (this.evAssists || 0);
+    }
+    get goalpass() {
+        return (this.totalGoals || 0) + (this.assists || 0);
+    }
+    get userMinutes() {
+        if (!this.gameTime) {
+            return '00:00';
+        }
+        const minutes = Math.floor(this.gameTime / 60);
+        const seconds = Math.floor(this.gameTime - minutes * 60);
+        return `${minutes < 10 ? 0 : ''}${minutes}:${seconds < 10 ? 0 : ''}${seconds}`;
+    }
+    get gamesWonPercent() {
+        if (!this.gamesCount) {
+            return 0;
+        }
+        return Math.floor(1000 * this.wonGamesCount / this.gamesCount) / 10;
+    }
+    get tournamentTeamPoints() {
+        return this.tournamentTeam && this.tournamentTeam.points;
+    }
+    static toFront(data) { }
+    static toBack(data) { }
+};
+__decorate([
+    ToFrontHook
+], WaterpoloStatistic, "toFront", null);
+__decorate([
+    ToBackHook
+], WaterpoloStatistic, "toBack", null);
+WaterpoloStatistic = __decorate([
+    ModelInstance({
+        mappingFields: {
+            league_player: 'leaguePlayer',
+            tournament_team_user: 'tournamentTeamUser',
+            team: 'team',
+            team_user: 'teamUser',
+            user: 'user',
+            tournament_team: 'tournamentTeam',
+            month: 'month',
+            win_lose: 'winLose',
+            games_count: 'gamesCount',
+            won_games_count: 'wonGamesCount',
+            lose_games_count: 'loseGamesCount',
+            points: 'points',
+            pp_shots: 'ppShots',
+            pp_shot_misses: 'ppShotMisses',
+            pp_shots_on_goal: 'ppShotsOnGoal',
+            pp_shots_blocked: 'ppShotsBlocked',
+            ev_shots: 'evShots',
+            ev_shot_misses: 'evShotMisses',
+            ev_shots_on_goal: 'evShotsOnGoal',
+            ev_shots_blocked: 'evShotsBlocked',
+            sh_shots: 'shShots',
+            sh_shot_misses: 'shShotMisses',
+            sh_shots_on_goal: 'shShotsOnGoal',
+            sh_shots_blocked: 'shShotsBlocked',
+            pp_goals_percent: 'ppGoalsPercent',
+            pp_goals: 'ppGoals',
+            ev_goals_percent: 'evGoalsPercent',
+            ev_goals: 'evGoals',
+            sh_goals_percent: 'shGoalsPercent',
+            goals: 'goals',
+            total_goals: 'totalGoals',
+            sh_goals: 'shGoals',
+            shot_misses: 'shotMisses',
+            shots_on_goal: 'shotsOnGoal',
+            shots_blocked: 'shotsBlocked',
+            shots: 'shots',
+            total_shots: 'totalShots',
+            goals_percent: 'goalsPercent',
+            total_goals_percent: 'totalGoalsPercent',
+            pp_assists: 'ppAssists',
+            ev_assists: 'evAssists',
+            sh_assists: 'shAssists',
+            shootout_attempts: 'shootoutAttempts',
+            shootout_goals: 'shootoutGoals',
+            after_game_shootout_attempts: 'afterGameShootoutAttempts',
+            after_game_shootout_goals: 'afterGameShootoutGoals',
+            block_shots: 'blockShots',
+            face_off_losses: 'faceOffLosses',
+            face_off_wins: 'faceOffWins',
+            face_offs: 'faceOffs',
+            face_off_percent: 'faceOffPercent',
+            saves: 'saves',
+            total_saves: 'totalSaves',
+            shootout_saves: 'shootoutSaves',
+            shots_against: 'shotsAgainst',
+            shootout_shots_against: 'shootoutShotsAgainst',
+            total_shots_against: 'totalShotsAgainst',
+            saves_percent: 'savesPercent',
+            total_saves_percent: 'totalSavesPercent',
+            goals_against: 'goalsAgainst',
+            shootout_goals_against: 'shootoutGoalsAgainst',
+            total_goals_against: 'totalGoalsAgainst',
+            safety_rate: 'safetyRate',
+            penalty_minutes: 'penaltyMinutes',
+            game_time: 'gameTime',
+            plus_minus: 'plusMinus',
+            free_kicks: 'freeKicks',
+            yellow_cards: 'yellowCards',
+            red_cards: 'redCards',
+            fouls: 'fouls',
+            losses: 'losses',
+            steals: 'steals',
+            drawn_fouls: 'drawnFouls',
+            newbie: 'newbie',
+            rank: 'rank',
+        },
+        relation: {
+            leaguePlayer: LeaguePlayer,
+            tournamentTeamUser: TournamentTeamUser,
+            team: Team,
+            teamUser: TeamUser,
+            user: User,
+            tournamentTeam: TournamentTeam,
+            month: DateField
+        }
+    })
+], WaterpoloStatistic);
+
 class TournamentApi {
     constructor(httpClient, configService) {
         this.httpClient = httpClient;
@@ -4888,6 +5149,18 @@ class TournamentApi {
             })).toPromise();
         });
     }
+    getWaterpoloStatisticLeaders(filters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let params = new HttpParams();
+            params = applyStatisticLeadersFilters(filters, params);
+            return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/waterpolo_statistic_leaders/`, { params }).pipe(map((result) => {
+                for (const key of Object.keys(result)) {
+                    result[key] = WaterpoloStatistic.toFront(result[key]);
+                }
+                return result;
+            })).toPromise();
+        });
+    }
     getBasketballStatistic(filters) {
         return __awaiter(this, void 0, void 0, function* () {
             let params = new HttpParams();
@@ -4948,6 +5221,16 @@ class TournamentApi {
             }))).toPromise();
         });
     }
+    getWaterpoloStatistic(filters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let params = new HttpParams();
+            params = applyStatisticFilters(filters, params);
+            return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/waterpolo_statistic/`, { params, observe: 'response' }).pipe(map(result => ({
+                total: +result.headers.get('X-Page-Count'),
+                data: WaterpoloStatistic.toFront(result.body)
+            }))).toPromise();
+        });
+    }
     getTournamentTeamUsers(tournamentTeamId) {
         return __awaiter(this, void 0, void 0, function* () {
             return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_team/${tournamentTeamId}/users/`).pipe(map(result => TournamentTeamUser.toFront(result))).toPromise();
@@ -7801,6 +8084,352 @@ VolleyballGameApi.ctorParameters = () => [
     { type: ConfigService }
 ];
 
+var WaterpoloGameLogTypes;
+(function (WaterpoloGameLogTypes) {
+    WaterpoloGameLogTypes[WaterpoloGameLogTypes["enter_game"] = 1] = "enter_game";
+    WaterpoloGameLogTypes[WaterpoloGameLogTypes["exit_game"] = 2] = "exit_game";
+    WaterpoloGameLogTypes[WaterpoloGameLogTypes["shot_miss"] = 3] = "shot_miss";
+    WaterpoloGameLogTypes[WaterpoloGameLogTypes["shot_on_goal"] = 4] = "shot_on_goal";
+    WaterpoloGameLogTypes[WaterpoloGameLogTypes["shot_blocked"] = 5] = "shot_blocked";
+    WaterpoloGameLogTypes[WaterpoloGameLogTypes["goal"] = 6] = "goal";
+    WaterpoloGameLogTypes[WaterpoloGameLogTypes["shootout_attempt"] = 7] = "shootout_attempt";
+    WaterpoloGameLogTypes[WaterpoloGameLogTypes["shootout_goal"] = 8] = "shootout_goal";
+    WaterpoloGameLogTypes[WaterpoloGameLogTypes["assist"] = 9] = "assist";
+    WaterpoloGameLogTypes[WaterpoloGameLogTypes["block_shot"] = 10] = "block_shot";
+    WaterpoloGameLogTypes[WaterpoloGameLogTypes["free_kick"] = 11] = "free_kick";
+    WaterpoloGameLogTypes[WaterpoloGameLogTypes["minor_penalty"] = 12] = "minor_penalty";
+    WaterpoloGameLogTypes[WaterpoloGameLogTypes["major_penalty"] = 13] = "major_penalty";
+    WaterpoloGameLogTypes[WaterpoloGameLogTypes["match_penalty"] = 14] = "match_penalty";
+    WaterpoloGameLogTypes[WaterpoloGameLogTypes["foul"] = 15] = "foul";
+    WaterpoloGameLogTypes[WaterpoloGameLogTypes["yellow_card"] = 16] = "yellow_card";
+    WaterpoloGameLogTypes[WaterpoloGameLogTypes["red_card"] = 17] = "red_card";
+    WaterpoloGameLogTypes[WaterpoloGameLogTypes["penalty_shot"] = 18] = "penalty_shot";
+    WaterpoloGameLogTypes[WaterpoloGameLogTypes["face_off_lose"] = 19] = "face_off_lose";
+    WaterpoloGameLogTypes[WaterpoloGameLogTypes["face_off_win"] = 20] = "face_off_win";
+    WaterpoloGameLogTypes[WaterpoloGameLogTypes["save"] = 21] = "save";
+    WaterpoloGameLogTypes[WaterpoloGameLogTypes["timeout"] = 22] = "timeout";
+    WaterpoloGameLogTypes[WaterpoloGameLogTypes["penalty_start"] = 23] = "penalty_start";
+    WaterpoloGameLogTypes[WaterpoloGameLogTypes["penalty_end"] = 24] = "penalty_end";
+    WaterpoloGameLogTypes[WaterpoloGameLogTypes["after_game_shootout_attempt"] = 25] = "after_game_shootout_attempt";
+    WaterpoloGameLogTypes[WaterpoloGameLogTypes["after_game_shootout_goal"] = 26] = "after_game_shootout_goal";
+    WaterpoloGameLogTypes[WaterpoloGameLogTypes["after_game_shootout_save"] = 27] = "after_game_shootout_save";
+    WaterpoloGameLogTypes[WaterpoloGameLogTypes["shootout_save"] = 28] = "shootout_save";
+    WaterpoloGameLogTypes[WaterpoloGameLogTypes["loss"] = 29] = "loss";
+    WaterpoloGameLogTypes[WaterpoloGameLogTypes["steal"] = 30] = "steal";
+})(WaterpoloGameLogTypes || (WaterpoloGameLogTypes = {}));
+var WaterpoloAdvantageTypes;
+(function (WaterpoloAdvantageTypes) {
+    WaterpoloAdvantageTypes[WaterpoloAdvantageTypes["power_play"] = 1] = "power_play";
+    WaterpoloAdvantageTypes[WaterpoloAdvantageTypes["shorthanded"] = 2] = "shorthanded";
+    WaterpoloAdvantageTypes[WaterpoloAdvantageTypes["even_strength"] = 3] = "even_strength";
+})(WaterpoloAdvantageTypes || (WaterpoloAdvantageTypes = {}));
+let WaterpoloGameLog = class WaterpoloGameLog extends BaseModel {
+    constructor() {
+        super(...arguments);
+        this.active = true;
+    }
+    get penalizedGameUserId() {
+        if (this._penalizedGameUserId) {
+            return this._penalizedGameUserId;
+        }
+        return this.gameUserId;
+    }
+    set penalizedGameUserId(value) {
+        this._penalizedGameUserId = value;
+    }
+    compare(model) {
+        if (this.time === model.time && this.period === model.period) {
+            return this.datetime.getTime() < model.datetime.getTime() ? 1 : -1;
+        }
+        if (this.period === model.period) {
+            return this.time < model.time ? 1 : -1;
+        }
+        return this.period < model.period ? 1 : -1;
+    }
+    get timeFormatted() {
+        const minutes = Math.floor(this.time / 60);
+        const seconds = this.time - minutes * 60;
+        return `${minutes < 10 ? '0' : ''}${minutes}:${seconds < 10 ? '0' : ''}${seconds}`;
+    }
+    isScoreType() {
+        return [WaterpoloGameLogTypes.goal, WaterpoloGameLogTypes.shootout_goal, WaterpoloGameLogTypes.after_game_shootout_goal].indexOf(this.logType) > -1;
+    }
+    isPenaltyType() {
+        return [
+            WaterpoloGameLogTypes.minor_penalty, WaterpoloGameLogTypes.major_penalty, WaterpoloGameLogTypes.match_penalty
+        ].indexOf(this.logType) > -1;
+    }
+    isAfter(log) {
+        if (this.time === log.time && this.period === log.period) {
+            return this.id > log.id;
+        }
+        if (this.period === log.period) {
+            return this.time > log.time;
+        }
+        return this.period > log.period;
+    }
+    static toFront(value) { }
+    static toBack(value) { }
+};
+__decorate([
+    ToFrontHook
+], WaterpoloGameLog, "toFront", null);
+__decorate([
+    ToBackHook
+], WaterpoloGameLog, "toBack", null);
+WaterpoloGameLog = __decorate([
+    ModelInstance({
+        mappingFields: {
+            id: 'id',
+            unique_id: 'uniqueId',
+            game_id: 'gameId',
+            game_user_id: 'gameUserId',
+            team_id: 'teamId',
+            log_type: 'logType',
+            datetime: 'datetime',
+            time: 'time',
+            period: 'period',
+            active: 'active',
+            is_highlight: 'isHighlight',
+            advantage: 'advantage',
+            advantage_num: 'advantageNum',
+            is_goalie: 'isGoalie',
+            penalized_game_user_id: 'penalizedGameUserId',
+            foul_on_game_user_id: 'foulOnGameUserId',
+            mutual_penalty: 'mutualPenalty',
+        },
+        relation: {
+            datetime: DateTimeField,
+            logType: enumField(WaterpoloGameLogTypes),
+            advantage: enumField(WaterpoloAdvantageTypes),
+        }
+    })
+], WaterpoloGameLog);
+
+let WaterpoloGameStatistic = class WaterpoloGameStatistic extends BaseModel {
+    get id() {
+        return this.gameUserId;
+    }
+    get shotsOnGoal() {
+        return (this.evShotsOnGoal || 0) + (this.ppShotsOnGoal || 0) + (this.shShotsOnGoal || 0);
+    }
+    get shotsBlocked() {
+        return (this.evShotsBlocked || 0) + (this.ppShotsBlocked || 0) + (this.shShotsBlocked || 0);
+    }
+    get shotMisses() {
+        return (this.evShotMisses || 0) + (this.ppShotMisses || 0) + (this.shShotMisses || 0);
+    }
+    get ppShots() {
+        return (this.ppShotMisses || 0) + (this.ppShotsOnGoal || 0) + (this.ppShotsBlocked || 0);
+    }
+    get evShots() {
+        return (this.evShotMisses || 0) + (this.evShotsOnGoal || 0) + (this.evShotsBlocked || 0);
+    }
+    get shShots() {
+        return (this.shShotMisses || 0) + (this.shShotsOnGoal || 0) + (this.shShotsBlocked || 0);
+    }
+    get shots() {
+        return this.ppShots + this.evShots + this.shShots + (this.shootoutAttempts || 0);
+    }
+    get totalShots() {
+        return this.shots + (this.shootoutAttempts || 0);
+    }
+    get goals() {
+        return (this.ppGoals || 0) + (this.shGoals || 0) + (this.evGoals || 0);
+    }
+    get totalGoals() {
+        return this.goals + (this.shootoutGoals || 0);
+    }
+    get assists() {
+        return (this.ppAssists || 0) + (this.evAssists || 0) + (this.shAssists || 0);
+    }
+    get faceOffs() {
+        return (this.faceOffWins || 0) + (this.faceOffLosses || 0);
+    }
+    get shootOuts() {
+        return (this.shootoutAttempts || 0) + (this.shootoutGoals || 0);
+    }
+    get shotsAgainst() {
+        return (this.saves || 0) + (this.goalsAgainst || 0);
+    }
+    get shootoutShotsAgainst() {
+        return (this.shootoutSaves || 0) + (this.shootoutGoalsAgainst || 0);
+    }
+    get totalShotsAgainst() {
+        return this.shotsAgainst + this.shootoutShotsAgainst;
+    }
+    get savesPercent() {
+        if (!this.shotsAgainst || !this.saves) {
+            return 0;
+        }
+        return Math.round(1000 * this.saves / this.shotsAgainst) / 10;
+    }
+    get totalSaves() {
+        return (this.saves || 0) + (this.shootoutSaves || 0);
+    }
+    get totalSavesPercent() {
+        if (!this.totalShotsAgainst || !this.totalSaves) {
+            return 0;
+        }
+        return Math.round(1000 * this.totalSaves / this.totalShotsAgainst) / 10;
+    }
+    get totalGoalsAgainst() {
+        return (this.goalsAgainst || 0) + (this.shootoutGoalsAgainst || 0);
+    }
+    get gameMinutes() {
+        return Math.floor(this.gameTime / 60);
+    }
+    get goalsPercent() {
+        if (!this.totalGoals || !this.totalShots) {
+            return 0;
+        }
+        return Math.round(1000 * this.totalGoals / this.totalShots) / 10;
+    }
+    get faceOffPercent() {
+        if (!this.faceOffWins || !this.faceOffs) {
+            return 0;
+        }
+        return Math.round(1000 * this.faceOffWins / this.faceOffs) / 10;
+    }
+    get goalpass() {
+        return (this.totalGoals || 0) + (this.assists || 0);
+    }
+    static toFront(data) { }
+    static toBack(data) { }
+};
+__decorate([
+    ToFrontHook
+], WaterpoloGameStatistic, "toFront", null);
+__decorate([
+    ToBackHook
+], WaterpoloGameStatistic, "toBack", null);
+WaterpoloGameStatistic = __decorate([
+    ModelInstance({
+        mappingFields: {
+            game_user_id: 'gameUserId',
+            updated_at: 'updatedAt',
+            points: 'points',
+            pp_shot_misses: 'ppShotMisses',
+            pp_shots_on_goal: 'ppShotsOnGoal',
+            pp_shots_blocked: 'ppShotsBlocked',
+            ev_shot_misses: 'evShotMisses',
+            ev_shots_on_goal: 'evShotsOnGoal',
+            ev_shots_blocked: 'evShotsBlocked',
+            sh_shot_misses: 'shShotMisses',
+            sh_shots_on_goal: 'shShotsOnGoal',
+            sh_shots_blocked: 'shShotsBlocked',
+            pp_goals: 'ppGoals',
+            ev_goals: 'evGoals',
+            sh_goals: 'shGoals',
+            pp_assists: 'ppAssists',
+            ev_assists: 'evAssists',
+            sh_assists: 'shAssists',
+            shootout_attempts: 'shootoutAttempts',
+            shootout_goals: 'shootoutGoals',
+            after_game_shootout_attempts: 'afterGameShootoutAttempts',
+            after_game_shootout_goals: 'afterGameShootoutGoals',
+            block_shots: 'blockShots',
+            face_off_losses: 'faceOffLosses',
+            face_off_wins: 'faceOffWins',
+            saves: 'saves',
+            shootout_save: 'shootoutSaves',
+            after_game_shootout_saves: 'afterGameShootoutSaves',
+            goals_against: 'goalsAgainst',
+            shootout_goals_against: 'shootoutGoalsAgainst',
+            after_game_shootout_goals_against: 'afterGameShootoutGoalsAgainst',
+            safety_rate: 'safetyRate',
+            penalty_minutes: 'penaltyMinutes',
+            game_time: 'gameTime',
+            plus_minus: 'plusMinus',
+            free_kicks: 'freeKicks',
+            yellow_cards: 'yellowCards',
+            red_cards: 'redCards',
+            fouls: 'fouls',
+            losses: 'losses',
+            steals: 'steals',
+            drawn_fouls: 'drawnFouls',
+        },
+        relation: {
+            updatedAt: DateTimeField,
+        }
+    })
+], WaterpoloGameStatistic);
+
+let WaterpoloGameTeamStatistic = class WaterpoloGameTeamStatistic extends BaseModel {
+    static toFront(data) { }
+    static toBack(data) { }
+};
+__decorate([
+    ToFrontHook
+], WaterpoloGameTeamStatistic, "toFront", null);
+__decorate([
+    ToBackHook
+], WaterpoloGameTeamStatistic, "toBack", null);
+WaterpoloGameTeamStatistic = __decorate([
+    ModelInstance({
+        mappingFields: {
+            team: 'team',
+            competitor_team: 'competitorTeam'
+        },
+        relation: {
+            team: WaterpoloStatistic,
+            competitorTeam: WaterpoloStatistic
+        }
+    })
+], WaterpoloGameTeamStatistic);
+
+class WaterpoloGameApi extends GameBaseApi {
+    constructor(httpClient, configService) {
+        super(httpClient, configService);
+        this.httpClient = httpClient;
+        this.configService = configService;
+    }
+    getById(gameId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_waterpolo_game/${gameId}/`).pipe(map(result => Game.toFront(result))).toPromise();
+        });
+    }
+    getTeamStatistic(gameId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_waterpolo_game/${gameId}/team_statistic/`).pipe(map(result => WaterpoloGameTeamStatistic.toFront(result))).toPromise();
+        });
+    }
+    getUserStatistic(gameId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_waterpolo_game/${gameId}/user_statistic/`).pipe(map(result => WaterpoloGameStatistic.toFront(result))).toPromise();
+        });
+    }
+    getLogs(gameId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_waterpolo_game/${gameId}/logs/`).pipe(map(result => WaterpoloGameLog.toFront(result))).toPromise();
+        });
+    }
+    downloadProtocol(gameId, format) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_waterpolo_game/${gameId}/game_protocol/`, {
+                params: new HttpParams().set('file_type', format),
+                responseType: 'blob'
+            }).toPromise();
+        });
+    }
+    downloadApplication(gameId, format, type) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_waterpolo_game/${gameId}/game_application_file/`, {
+                params: new HttpParams().set('file_type', format).set('application_type', type),
+                responseType: 'blob'
+            }).toPromise();
+        });
+    }
+}
+WaterpoloGameApi.ɵprov = i0.ɵɵdefineInjectable({ factory: function WaterpoloGameApi_Factory() { return new WaterpoloGameApi(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(ConfigService)); }, token: WaterpoloGameApi, providedIn: "root" });
+WaterpoloGameApi.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
+WaterpoloGameApi.ctorParameters = () => [
+    { type: HttpClient },
+    { type: ConfigService }
+];
+
 class PublicTeamApi {
     constructor(httpClient, configService) {
         this.httpClient = httpClient;
@@ -7992,6 +8621,39 @@ const HandballGameLogTypeLocalization = {
     [HandballGameLogTypes.timeout]: 'Таймаут'
 };
 
+const WaterpoloGameLogTypeLocalization = {
+    [WaterpoloGameLogTypes.enter_game]: 'Выход на площадку',
+    [WaterpoloGameLogTypes.exit_game]: 'Ушел с площадки',
+    [WaterpoloGameLogTypes.shot_miss]: 'Бросок мимо',
+    [WaterpoloGameLogTypes.shot_on_goal]: 'Бросок по воротам',
+    [WaterpoloGameLogTypes.shot_blocked]: 'Заблокированный бросок',
+    [WaterpoloGameLogTypes.goal]: 'Гол',
+    [WaterpoloGameLogTypes.shootout_attempt]: 'Пенальти промах',
+    [WaterpoloGameLogTypes.shootout_goal]: 'Пенальти гол',
+    [WaterpoloGameLogTypes.after_game_shootout_attempt]: 'Пенальти промах',
+    [WaterpoloGameLogTypes.after_game_shootout_goal]: 'Пенальти гол',
+    [WaterpoloGameLogTypes.assist]: 'Передача',
+    [WaterpoloGameLogTypes.block_shot]: 'Блокировка броска',
+    [WaterpoloGameLogTypes.minor_penalty]: 'Штраф 20 сек.',
+    [WaterpoloGameLogTypes.major_penalty]: 'Штраф 4 мин.',
+    [WaterpoloGameLogTypes.match_penalty]: 'Матч-штраф',
+    [WaterpoloGameLogTypes.foul]: 'Фол',
+    [WaterpoloGameLogTypes.penalty_shot]: 'Штрафной бросок',
+    [WaterpoloGameLogTypes.face_off_lose]: 'Проигрыш в спринте',
+    [WaterpoloGameLogTypes.face_off_win]: 'Победа в спринте',
+    [WaterpoloGameLogTypes.save]: 'Отражен бросок',
+    [WaterpoloGameLogTypes.shootout_save]: 'Отражен бросок',
+    [WaterpoloGameLogTypes.after_game_shootout_save]: 'Отражен бросок',
+    [WaterpoloGameLogTypes.timeout]: 'Таймаут',
+    [WaterpoloGameLogTypes.penalty_start]: 'Начало штрафного времени',
+    [WaterpoloGameLogTypes.penalty_end]: 'Конец штрафного времени',
+    [WaterpoloGameLogTypes.yellow_card]: 'Желтая карточка',
+    [WaterpoloGameLogTypes.red_card]: 'Красная карточка',
+    [WaterpoloGameLogTypes.free_kick]: 'Свободный удар',
+    [WaterpoloGameLogTypes.loss]: 'Потеря',
+    [WaterpoloGameLogTypes.steal]: 'Перехват'
+};
+
 const OvertimeTypeLocalization = {
     [OvertimeTypes.to_score_diff]: 'До разницы в N мячей',
     [OvertimeTypes.to_score_total]: 'До N очков',
@@ -8143,6 +8805,22 @@ const GameRugbyPositionLocalization = {
     [GameRugbyPosition.three_quarter]: 'Трехчетвертный',
     [GameRugbyPosition.fullback]: 'Замыкающий'
 };
+const GameWaterpoloPositionLocalization = {
+    [GameWaterpoloPosition.defensemen]: 'Защитник',
+    [GameWaterpoloPosition.goalkeeper]: 'Вратарь',
+    [GameWaterpoloPosition.center_forward]: 'Центральный нападающий',
+    [GameWaterpoloPosition.mobile_forward]: 'Подвижный нападающий',
+};
+const GameWaterpoloPositionShortRuLocalization = {
+    [GameWaterpoloPosition.defensemen]: 'З',
+    [GameWaterpoloPosition.goalkeeper]: 'Вр',
+    [GameWaterpoloPosition.center_forward]: 'ЦН',
+    [GameWaterpoloPosition.mobile_forward]: 'ПН',
+};
+const WaterpoloWorkHandLocalization = {
+    [WaterpoloWorkHand.left]: 'Левая',
+    [WaterpoloWorkHand.right]: 'Правая'
+};
 
 const VolleyballGameLogTypeLocalization = {
     [VolleyballGameLogType.enter_game]: 'Выход на площадку',
@@ -8721,5 +9399,5 @@ HttpCookieInterceptor.ctorParameters = () => [
  * Generated bundle index. Do not edit.
  */
 
-export { Achievement, AchievementTypes, BannerLocation, BaseModel, BaseService, BasketballCourtSides, BasketballCourtZones, BasketballGameApi, BasketballGameConfig, BasketballGameLog, BasketballGameLogTypeLocalization, BasketballGameLogTypes, BasketballGameStatistic, BasketballGameSubLogTypesLocalization, BasketballGameTeamStatistic, BasketballPenaltyTypes, BasketballProfile, BasketballStatistic, BasketballStatisticTypes, BasketballSubLogTypes, CONFIG_DATA, CentrifugoService, City, ConfigService, DateField, DateTimeField, FAULT_LOG_TYPES, Feedback, FeedbackApi, File, FileApi, FileEngine, FootballGameApi, FootballGameConfig, FootballGameLog, FootballGameLogTypeLocalization, FootballGameLogTypes, FootballGameStatistic, FootballGameTeamStatistic, FootballProfile, FootballStatistic, FootballWorkFoot, FootballWorkFootLocalization, Game, GameBaseApi, GameBasketballPosition, GameBasketballPositionLocalization, GameBasketballPositionShortLocalization, GameBill, GameBillStatusLocalization, GameBillStatuses, GameFootballPosition, GameFootballPositionLocalization, GameHandballPosition, GameHandballPositionLocalization, GameHockeyPosition, GameHockeyPositionLocalization, GameInvite, GameInviteStatus, GameResultTypes, GameRugbyPosition, GameRugbyPositionLocalization, GameStatuses, GameTimeTypes, GameTimelineStageItem, GameTimelineStages, GameUser, GameUserDisqualification, GameUserLimitationTypes, GameUserLimitations, GameVolleyballPosition, GameVolleyballPositionLocalization, GameVolleyballPositionShortLocalization, GameVolleyballPositionShortRuLocalization, HandballGameApi, HandballGameConfig, HandballGameLog, HandballGameLogTypeLocalization, HandballGameLogTypes, HandballGameStatistic, HandballGameTeamStatistic, HandballProfile, HandballStatistic, HockeyAdvantageTypes, HockeyGameApi, HockeyGameConfig, HockeyGameLog, HockeyGameLogTypeLocalization, HockeyGameLogTypes, HockeyGameStatistic, HockeyGameTeamStatistic, HockeyPenaltyTypes, HockeyProfile, HockeyStatistic, HockeyWorkHand, HockeyWorkHandLocalization, HttpCookieInterceptor, League, LeagueApi, LeagueBanner, LeagueCourt, LeagueDocument, LeagueNews, LeagueNewsApi, LeagueNewsType, LeaguePartner, LeaguePlayer, LeaguePlayerApi, LeaguePlaylist, LocalStorageEngine, MODEL_MAPPING_FIELDS_KEY, MODEL_RELATION_KEY, MODEL_TO_BACK_KEY, MODEL_TO_FRONT_KEY, MediaApi, MediaItem, ModelInstance, Notification, NotificationAllowTypes, NotificationApi, NotificationBaseApi, NotificationServiceEnum, NotificationSettings, NotificationType, OrgNotificationApi, Organization, OrganizationBill, OrganizationBillStatusLocalization, OrganizationBillStatuses, OrganizationStatistic, OrganizationStatuses, OrganizationStatusesLocalization, OrganizationTariff, OvertimeTypeLocalization, OvertimeTypes, Playoff, PlayoffSettings, PlayoffTypes, Poll, PollAnswer, PollStatuses, PollVariant, PublicTeamApi, PublicUserApi, Qualification, QualificationLocalization, RUGBY_GAME_LOG_TYPE_POINTS, RUGBY_TEAM_LOG_TYPES, ReferenceApi, RugbyFoulSanctionLocalization, RugbyFoulSanctions, RugbyFoulType, RugbyGameApi, RugbyGameConfig, RugbyGameLog, RugbyGameLogTypeLocalization, RugbyGameLogTypes, RugbyGameStatistic, RugbyGameTeamStatistic, RugbyProfile, RugbyStatistic, RugbyStatisticTypes, SCORE_LOG_TYPES, Sport, SportTypes, StorageEngine, StorageEngineField, Store, Team, TeamAccess, TeamAchievement, TeamApi, TeamEvent, TeamEventApi, TeamEventInvite, TeamEventInviteStatuses, TeamEventTypeLocalization, TeamEventTypes, TeamInvite, TeamInviteExternal, TeamPermission, TeamPermissionTypes, TeamUser, TeamUserRole, TeamUserRoleLocalization, TeamsAndUsers, ToBackHook, ToFrontHook, Tournament, TournamentApi, TournamentDisqualification, TournamentEvent, TournamentEventTypes, TournamentGender, TournamentGroup, TournamentInvite, TournamentJoin1x1Data, TournamentJoin1x1Status, TournamentJoinApi, TournamentJoinData, TournamentJoinTeam, TournamentNews, TournamentSeason, TournamentSeasonApi, TournamentSeasonStatuses, TournamentSettings, TournamentStage, TournamentStageApi, TournamentStageStatuses, TournamentStageTeam, TournamentStatuses, TournamentTeam, TournamentTeamShort, TournamentTeamUser, TournamentTeamUserInvite, TournamentTeamWinner, TournamentTypes, UntilDestroy, User, UserAccess, UserApi, UserGender, UserPermission, UserPermissionTypes, UserProfile, VolleyballGameApi, VolleyballGameConfig, VolleyballGameLog, VolleyballGameLogType, VolleyballGameLogTypeLocalization, VolleyballGameStatistic, VolleyballGameTeamStatistic, VolleyballGameTypes, VolleyballProfile, VolleyballStatistic, VolleyballStatisticTypes, VolleyballWorkHand, VolleyballWorkHandLocalization, WorkHand, WorkHandLocalization, addItemInArray, addItemsInArray, applyGameMediaFilters, applyGamesFilters, applyStatisticFilters, applyStatisticLeadersFilters, changeFavicons, componentDestroyed, deleteItemFromArray, enumField, fileSizeValidator, generateArray, getArrayChunks, getCookie, getEnumOptions, getIconsData, handleError, isTouchDevice, listField, markFormGroupTouched, minLengthArrayValidator, parseDate, patchItemInArray, penaltyTypeField, updateItemInArray, updateItemsInArray, validateDate, validateEmail, validatePhone, validateUrl };
+export { Achievement, AchievementTypes, BannerLocation, BaseModel, BaseService, BasketballCourtSides, BasketballCourtZones, BasketballGameApi, BasketballGameConfig, BasketballGameLog, BasketballGameLogTypeLocalization, BasketballGameLogTypes, BasketballGameStatistic, BasketballGameSubLogTypesLocalization, BasketballGameTeamStatistic, BasketballPenaltyTypes, BasketballProfile, BasketballStatistic, BasketballStatisticTypes, BasketballSubLogTypes, CONFIG_DATA, CentrifugoService, City, ConfigService, DateField, DateTimeField, FAULT_LOG_TYPES, Feedback, FeedbackApi, File, FileApi, FileEngine, FootballGameApi, FootballGameConfig, FootballGameLog, FootballGameLogTypeLocalization, FootballGameLogTypes, FootballGameStatistic, FootballGameTeamStatistic, FootballProfile, FootballStatistic, FootballWorkFoot, FootballWorkFootLocalization, Game, GameBaseApi, GameBasketballPosition, GameBasketballPositionLocalization, GameBasketballPositionShortLocalization, GameBill, GameBillStatusLocalization, GameBillStatuses, GameFootballPosition, GameFootballPositionLocalization, GameHandballPosition, GameHandballPositionLocalization, GameHockeyPosition, GameHockeyPositionLocalization, GameInvite, GameInviteStatus, GameResultTypes, GameRugbyPosition, GameRugbyPositionLocalization, GameStatuses, GameTimeTypes, GameTimelineStageItem, GameTimelineStages, GameUser, GameUserDisqualification, GameUserLimitationTypes, GameUserLimitations, GameVolleyballPosition, GameVolleyballPositionLocalization, GameVolleyballPositionShortLocalization, GameVolleyballPositionShortRuLocalization, GameWaterpoloPosition, GameWaterpoloPositionLocalization, GameWaterpoloPositionShortRuLocalization, HandballGameApi, HandballGameConfig, HandballGameLog, HandballGameLogTypeLocalization, HandballGameLogTypes, HandballGameStatistic, HandballGameTeamStatistic, HandballProfile, HandballStatistic, HockeyAdvantageTypes, HockeyGameApi, HockeyGameConfig, HockeyGameLog, HockeyGameLogTypeLocalization, HockeyGameLogTypes, HockeyGameStatistic, HockeyGameTeamStatistic, HockeyPenaltyTypes, HockeyProfile, HockeyStatistic, HockeyWorkHand, HockeyWorkHandLocalization, HttpCookieInterceptor, League, LeagueApi, LeagueBanner, LeagueCourt, LeagueDocument, LeagueNews, LeagueNewsApi, LeagueNewsType, LeaguePartner, LeaguePlayer, LeaguePlayerApi, LeaguePlaylist, LocalStorageEngine, MODEL_MAPPING_FIELDS_KEY, MODEL_RELATION_KEY, MODEL_TO_BACK_KEY, MODEL_TO_FRONT_KEY, MediaApi, MediaItem, ModelInstance, Notification, NotificationAllowTypes, NotificationApi, NotificationBaseApi, NotificationServiceEnum, NotificationSettings, NotificationType, OrgNotificationApi, Organization, OrganizationBill, OrganizationBillStatusLocalization, OrganizationBillStatuses, OrganizationStatistic, OrganizationStatuses, OrganizationStatusesLocalization, OrganizationTariff, OvertimeTypeLocalization, OvertimeTypes, Playoff, PlayoffSettings, PlayoffTypes, Poll, PollAnswer, PollStatuses, PollVariant, PublicTeamApi, PublicUserApi, Qualification, QualificationLocalization, RUGBY_GAME_LOG_TYPE_POINTS, RUGBY_TEAM_LOG_TYPES, ReferenceApi, RugbyFoulSanctionLocalization, RugbyFoulSanctions, RugbyFoulType, RugbyGameApi, RugbyGameConfig, RugbyGameLog, RugbyGameLogTypeLocalization, RugbyGameLogTypes, RugbyGameStatistic, RugbyGameTeamStatistic, RugbyProfile, RugbyStatistic, RugbyStatisticTypes, SCORE_LOG_TYPES, Sport, SportTypes, StorageEngine, StorageEngineField, Store, Team, TeamAccess, TeamAchievement, TeamApi, TeamEvent, TeamEventApi, TeamEventInvite, TeamEventInviteStatuses, TeamEventTypeLocalization, TeamEventTypes, TeamInvite, TeamInviteExternal, TeamPermission, TeamPermissionTypes, TeamUser, TeamUserRole, TeamUserRoleLocalization, TeamsAndUsers, ToBackHook, ToFrontHook, Tournament, TournamentApi, TournamentDisqualification, TournamentEvent, TournamentEventTypes, TournamentGender, TournamentGroup, TournamentInvite, TournamentJoin1x1Data, TournamentJoin1x1Status, TournamentJoinApi, TournamentJoinData, TournamentJoinTeam, TournamentNews, TournamentSeason, TournamentSeasonApi, TournamentSeasonStatuses, TournamentSettings, TournamentStage, TournamentStageApi, TournamentStageStatuses, TournamentStageTeam, TournamentStatuses, TournamentTeam, TournamentTeamShort, TournamentTeamUser, TournamentTeamUserInvite, TournamentTeamWinner, TournamentTypes, UntilDestroy, User, UserAccess, UserApi, UserGender, UserPermission, UserPermissionTypes, UserProfile, VolleyballGameApi, VolleyballGameConfig, VolleyballGameLog, VolleyballGameLogType, VolleyballGameLogTypeLocalization, VolleyballGameStatistic, VolleyballGameTeamStatistic, VolleyballGameTypes, VolleyballProfile, VolleyballStatistic, VolleyballStatisticTypes, VolleyballWorkHand, VolleyballWorkHandLocalization, WaterpoloAdvantageTypes, WaterpoloGameApi, WaterpoloGameConfig, WaterpoloGameLog, WaterpoloGameLogTypeLocalization, WaterpoloGameLogTypes, WaterpoloGameStatistic, WaterpoloGameTeamStatistic, WaterpoloProfile, WaterpoloStatistic, WaterpoloWorkHand, WaterpoloWorkHandLocalization, WorkHand, WorkHandLocalization, addItemInArray, addItemsInArray, applyGameMediaFilters, applyGamesFilters, applyStatisticFilters, applyStatisticLeadersFilters, changeFavicons, componentDestroyed, deleteItemFromArray, enumField, fileSizeValidator, generateArray, getArrayChunks, getCookie, getEnumOptions, getIconsData, handleError, isTouchDevice, listField, markFormGroupTouched, minLengthArrayValidator, parseDate, patchItemInArray, penaltyTypeField, updateItemInArray, updateItemsInArray, validateDate, validateEmail, validatePhone, validateUrl };
 //# sourceMappingURL=mtgame-core.js.map