@mtgame/core 0.1.114 → 0.1.115

package/bundles/mtgame-core.umd.js

@@ -777,6 +777,9 @@
         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";
     })(exports.SportTypes || (exports.SportTypes = {}));
     exports.Sport = /** @class */ (function (_super) {
         __extends(Sport, _super);
@@ -837,6 +840,15 @@
         Sport.prototype.isRugby7 = function () {
             return this.id === exports.SportTypes.rugby7;
         };
+        Sport.prototype.isWaterpolo = function () {
+            return this.id === exports.SportTypes.waterpolo || this.parentId === exports.SportTypes.waterpolo;
+        };
+        Sport.prototype.isClassicWaterpolo = function () {
+            return this.id === exports.SportTypes.classic_waterpolo;
+        };
+        Sport.prototype.isMiniWaterpolo = function () {
+            return this.id === exports.SportTypes.mini_waterpolo;
+        };
         Sport.toFront = function (data) {
             return null;
         };
@@ -1167,6 +1179,50 @@
         })
     ], exports.RugbyProfile);
 
+    exports.GameWaterpoloPosition = void 0;
+    (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";
+    })(exports.GameWaterpoloPosition || (exports.GameWaterpoloPosition = {}));
+    exports.WaterpoloWorkHand = void 0;
+    (function (WaterpoloWorkHand) {
+        WaterpoloWorkHand[WaterpoloWorkHand["left"] = 1] = "left";
+        WaterpoloWorkHand[WaterpoloWorkHand["right"] = 2] = "right";
+    })(exports.WaterpoloWorkHand || (exports.WaterpoloWorkHand = {}));
+    exports.WaterpoloProfile = /** @class */ (function (_super) {
+        __extends(WaterpoloProfile, _super);
+        function WaterpoloProfile() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        WaterpoloProfile.toFront = function (value) {
+        };
+        WaterpoloProfile.toBack = function (value) {
+        };
+        return WaterpoloProfile;
+    }(BaseModel));
+    __decorate([
+        ToFrontHook
+    ], exports.WaterpoloProfile, "toFront", null);
+    __decorate([
+        ToBackHook
+    ], exports.WaterpoloProfile, "toBack", null);
+    exports.WaterpoloProfile = __decorate([
+        ModelInstance({
+            mappingFields: {
+                id: 'id',
+                user_id: 'userId',
+                position: 'position',
+                work_hand: 'workHand'
+            },
+            relation: {
+                position: enumField(exports.GameWaterpoloPosition),
+                workHand: enumField(exports.WaterpoloWorkHand)
+            }
+        })
+    ], exports.WaterpoloProfile);
+
     exports.UserGender = void 0;
     (function (UserGender) {
         UserGender[UserGender["male"] = 1] = "male";
@@ -1241,6 +1297,7 @@
                 football_profile: 'footballProfile',
                 handball_profile: 'handballProfile',
                 rugby_profile: 'rugbyProfile',
+                wateprolo_profile: 'waterpoloProfile',
                 wizards: 'wizards',
                 city: 'city',
                 gender: 'gender',
@@ -1256,6 +1313,7 @@
                 footballProfile: exports.FootballProfile,
                 handballProfile: exports.HandballProfile,
                 rugbyProfile: exports.RugbyProfile,
+                waterpoloProfile: exports.WaterpoloProfile,
                 city: exports.City,
                 gender: enumField(exports.UserGender)
             }
@@ -1284,6 +1342,12 @@
             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(' ');
         };
         Team.toFront = function (data) {
@@ -1690,6 +1754,15 @@
             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(' ');
         };
         Tournament.toFront = function (data) { };
@@ -2239,6 +2312,63 @@
         })
     ], exports.RugbyGameConfig);
 
+    exports.WaterpoloGameConfig = /** @class */ (function (_super) {
+        __extends(WaterpoloGameConfig, _super);
+        function WaterpoloGameConfig() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        WaterpoloGameConfig.toFront = function (data) { };
+        WaterpoloGameConfig.toBack = function (data) { };
+        Object.defineProperty(WaterpoloGameConfig.prototype, "overtimePeriod", {
+            get: function () {
+                return this.periodsCount + 1;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(WaterpoloGameConfig.prototype, "bullitsPeriod", {
+            get: function () {
+                return this.periodsCount + 2;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(WaterpoloGameConfig.prototype, "playoffBullitsPeriod", {
+            get: function () {
+                return this.periodsCount + 3;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        return WaterpoloGameConfig;
+    }(BaseModel));
+    __decorate([
+        ToFrontHook
+    ], exports.WaterpoloGameConfig, "toFront", null);
+    __decorate([
+        ToBackHook
+    ], exports.WaterpoloGameConfig, "toBack", null);
+    exports.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(exports.OvertimeTypes),
+                gameTimeType: enumField(exports.GameTimeTypes),
+            }
+        })
+    ], exports.WaterpoloGameConfig);
+
     exports.GameStatuses = void 0;
     (function (GameStatuses) {
         GameStatuses[GameStatuses["open"] = 1] = "open";
@@ -2382,6 +2512,22 @@
             enumerable: false,
             configurable: true
         });
+        Object.defineProperty(Game.prototype, "waterpoloGameConfig", {
+            get: function () {
+                if (this._waterpoloGameConfig && this._waterpoloGameConfig.periodsCount) {
+                    return this._waterpoloGameConfig;
+                }
+                if (this.gameConfig) {
+                    this._waterpoloGameConfig = exports.WaterpoloGameConfig.toFront(this.gameConfig);
+                }
+                return this._waterpoloGameConfig;
+            },
+            set: function (value) {
+                this._waterpoloGameConfig = value;
+            },
+            enumerable: false,
+            configurable: true
+        });
         Object.defineProperty(Game.prototype, "scoreByPeriodList", {
             get: function () {
                 var _this = this;
@@ -2473,6 +2619,7 @@
                 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',
@@ -2499,6 +2646,8 @@
                 hockeyGameConfig: exports.HockeyGameConfig,
                 footballGameConfig: exports.FootballGameConfig,
                 handballGameConfig: exports.HandballGameConfig,
+                rugbyGameConfig: exports.RugbyGameConfig,
+                waterpoloGameConfig: exports.WaterpoloGameConfig,
                 tournamentPlayoff: exports.Playoff,
                 tournamentCourt: exports.LeagueCourt,
                 media: listField(exports.MediaItem),
@@ -2871,16 +3020,16 @@
         })
     ], exports.TournamentDisqualification);
 
-    var _a$g;
+    var _a$h;
     exports.Qualification = void 0;
     (function (Qualification) {
         Qualification[Qualification["practician"] = 1] = "practician";
         Qualification[Qualification["amateur"] = 2] = "amateur";
     })(exports.Qualification || (exports.Qualification = {}));
-    var QualificationLocalization = (_a$g = {},
-        _a$g[exports.Qualification.practician] = 'Практик',
-        _a$g[exports.Qualification.amateur] = 'Любитель',
-        _a$g);
+    var QualificationLocalization = (_a$h = {},
+        _a$h[exports.Qualification.practician] = 'Практик',
+        _a$h[exports.Qualification.amateur] = 'Любитель',
+        _a$h);
     exports.LeaguePlayer = /** @class */ (function (_super) {
         __extends(LeaguePlayer, _super);
         function LeaguePlayer() {
@@ -6102,6 +6251,155 @@
         })
     ], exports.TeamAchievement);
 
+    exports.WaterpoloStatistic = /** @class */ (function (_super) {
+        __extends(WaterpoloStatistic, _super);
+        function WaterpoloStatistic() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        Object.defineProperty(WaterpoloStatistic.prototype, "assists", {
+            get: function () {
+                return (this.ppAssists || 0) + (this.shAssists || 0) + (this.evAssists || 0);
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(WaterpoloStatistic.prototype, "goalpass", {
+            get: function () {
+                return (this.totalGoals || 0) + (this.assists || 0);
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(WaterpoloStatistic.prototype, "userMinutes", {
+            get: function () {
+                if (!this.gameTime) {
+                    return '00:00';
+                }
+                var minutes = Math.floor(this.gameTime / 60);
+                var seconds = Math.floor(this.gameTime - minutes * 60);
+                return "" + (minutes < 10 ? 0 : '') + minutes + ":" + (seconds < 10 ? 0 : '') + seconds;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(WaterpoloStatistic.prototype, "gamesWonPercent", {
+            get: function () {
+                if (!this.gamesCount) {
+                    return 0;
+                }
+                return Math.floor(1000 * this.wonGamesCount / this.gamesCount) / 10;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(WaterpoloStatistic.prototype, "tournamentTeamPoints", {
+            get: function () {
+                return this.tournamentTeam && this.tournamentTeam.points;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        WaterpoloStatistic.toFront = function (data) { };
+        WaterpoloStatistic.toBack = function (data) { };
+        return WaterpoloStatistic;
+    }(BaseModel));
+    __decorate([
+        ToFrontHook
+    ], exports.WaterpoloStatistic, "toFront", null);
+    __decorate([
+        ToBackHook
+    ], exports.WaterpoloStatistic, "toBack", null);
+    exports.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: exports.LeaguePlayer,
+                tournamentTeamUser: exports.TournamentTeamUser,
+                team: exports.Team,
+                teamUser: exports.TeamUser,
+                user: exports.User,
+                tournamentTeam: exports.TournamentTeam,
+                month: DateField
+            }
+        })
+    ], exports.WaterpoloStatistic);
+
     var TournamentApi = /** @class */ (function () {
         function TournamentApi(httpClient, configService) {
             this.httpClient = httpClient;
@@ -6436,6 +6734,32 @@
                 });
             });
         };
+        TournamentApi.prototype.getWaterpoloStatisticLeaders = function (filters) {
+            return __awaiter(this, void 0, void 0, function () {
+                var params;
+                return __generator(this, function (_a) {
+                    params = new i1.HttpParams();
+                    params = applyStatisticLeadersFilters(filters, params);
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/waterpolo_statistic_leaders/", { params: params }).pipe(operators.map(function (result) {
+                            var e_6, _a;
+                            try {
+                                for (var _b = __values(Object.keys(result)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                                    var key = _c.value;
+                                    result[key] = exports.WaterpoloStatistic.toFront(result[key]);
+                                }
+                            }
+                            catch (e_6_1) { e_6 = { error: e_6_1 }; }
+                            finally {
+                                try {
+                                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                                }
+                                finally { if (e_6) throw e_6.error; }
+                            }
+                            return result;
+                        })).toPromise()];
+                });
+            });
+        };
         TournamentApi.prototype.getBasketballStatistic = function (filters) {
             return __awaiter(this, void 0, void 0, function () {
                 var params;
@@ -6514,6 +6838,19 @@
                 });
             });
         };
+        TournamentApi.prototype.getWaterpoloStatistic = function (filters) {
+            return __awaiter(this, void 0, void 0, function () {
+                var params;
+                return __generator(this, function (_a) {
+                    params = new i1.HttpParams();
+                    params = applyStatisticFilters(filters, params);
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/waterpolo_statistic/", { params: params, observe: 'response' }).pipe(operators.map(function (result) { return ({
+                            total: +result.headers.get('X-Page-Count'),
+                            data: exports.WaterpoloStatistic.toFront(result.body)
+                        }); })).toPromise()];
+                });
+            });
+        };
         TournamentApi.prototype.getTournamentTeamUsers = function (tournamentTeamId) {
             return __awaiter(this, void 0, void 0, function () {
                 return __generator(this, function (_a) {
@@ -6596,7 +6933,7 @@
         return params;
     }
     function applyStatisticFilters(filters, params) {
-        var e_6, _a;
+        var e_7, _a;
         try {
             for (var _b = __values(Object.keys(filters)), _c = _b.next(); !_c.done; _c = _b.next()) {
                 var key = _c.value;
@@ -6605,12 +6942,12 @@
                 }
             }
         }
-        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
         finally {
             try {
                 if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
-            finally { if (e_6) throw e_6.error; }
+            finally { if (e_7) throw e_7.error; }
         }
         if (filters.per_game !== undefined) {
             params = params.set('per_game', filters.per_game ? '1' : '0');
@@ -6624,7 +6961,7 @@
         return params;
     }
     function applyStatisticLeadersFilters(filters, params) {
-        var e_7, _a;
+        var e_8, _a;
         try {
             for (var _b = __values(Object.keys(filters)), _c = _b.next(); !_c.done; _c = _b.next()) {
                 var key = _c.value;
@@ -6633,12 +6970,12 @@
                 }
             }
         }
-        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        catch (e_8_1) { e_8 = { error: e_8_1 }; }
         finally {
             try {
                 if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
-            finally { if (e_7) throw e_7.error; }
+            finally { if (e_8) throw e_8.error; }
         }
         if (filters.per_game !== undefined) {
             params = params.set('per_game', filters.per_game ? '1' : '0');
@@ -7416,11 +7753,11 @@
         TeamEventTypes[TeamEventTypes["other"] = 2] = "other";
     })(exports.TeamEventTypes || (exports.TeamEventTypes = {}));
 
-    var _a$f;
-    var TeamEventTypeLocalization = (_a$f = {},
-        _a$f[exports.TeamEventTypes.training] = 'Тренировка',
-        _a$f[exports.TeamEventTypes.other] = 'Другое',
-        _a$f);
+    var _a$g;
+    var TeamEventTypeLocalization = (_a$g = {},
+        _a$g[exports.TeamEventTypes.training] = 'Тренировка',
+        _a$g[exports.TeamEventTypes.other] = 'Другое',
+        _a$g);
 
     exports.TeamEvent = /** @class */ (function (_super) {
         __extends(TeamEvent, _super);
@@ -8033,7 +8370,7 @@
         })
     ], exports.RugbyFoulType);
 
-    var _a$e;
+    var _a$f;
     exports.RugbyGameLogTypes = void 0;
     (function (RugbyGameLogTypes) {
         RugbyGameLogTypes[RugbyGameLogTypes["enter_game"] = 1] = "enter_game";
@@ -8074,14 +8411,14 @@
         RugbyGameLogTypes[RugbyGameLogTypes["maul_lost"] = 35] = "maul_lost";
         RugbyGameLogTypes[RugbyGameLogTypes["team_foul"] = 36] = "team_foul";
     })(exports.RugbyGameLogTypes || (exports.RugbyGameLogTypes = {}));
-    var RUGBY_GAME_LOG_TYPE_POINTS = (_a$e = {},
-        _a$e[exports.RugbyGameLogTypes.penalty_try] = 7,
-        _a$e[exports.RugbyGameLogTypes.try] = 5,
-        _a$e[exports.RugbyGameLogTypes.conversion_goal] = 2,
-        _a$e[exports.RugbyGameLogTypes.penalty_goal] = 3,
-        _a$e[exports.RugbyGameLogTypes.drop_goal] = 3,
-        _a$e[exports.RugbyGameLogTypes.end_game_penalty_goal] = 1,
-        _a$e);
+    var RUGBY_GAME_LOG_TYPE_POINTS = (_a$f = {},
+        _a$f[exports.RugbyGameLogTypes.penalty_try] = 7,
+        _a$f[exports.RugbyGameLogTypes.try] = 5,
+        _a$f[exports.RugbyGameLogTypes.conversion_goal] = 2,
+        _a$f[exports.RugbyGameLogTypes.penalty_goal] = 3,
+        _a$f[exports.RugbyGameLogTypes.drop_goal] = 3,
+        _a$f[exports.RugbyGameLogTypes.end_game_penalty_goal] = 1,
+        _a$f);
     var RUGBY_TEAM_LOG_TYPES = [
         exports.RugbyGameLogTypes.timeout, exports.RugbyGameLogTypes.scrum_won, exports.RugbyGameLogTypes.scrum_lost, exports.RugbyGameLogTypes.scrum_won_free,
         exports.RugbyGameLogTypes.lineout_won, exports.RugbyGameLogTypes.lineout_lost,
@@ -9977,6 +10314,488 @@
         { type: ConfigService }
     ]; };
 
+    exports.WaterpoloGameLogTypes = void 0;
+    (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";
+    })(exports.WaterpoloGameLogTypes || (exports.WaterpoloGameLogTypes = {}));
+    exports.WaterpoloAdvantageTypes = void 0;
+    (function (WaterpoloAdvantageTypes) {
+        WaterpoloAdvantageTypes[WaterpoloAdvantageTypes["power_play"] = 1] = "power_play";
+        WaterpoloAdvantageTypes[WaterpoloAdvantageTypes["shorthanded"] = 2] = "shorthanded";
+        WaterpoloAdvantageTypes[WaterpoloAdvantageTypes["even_strength"] = 3] = "even_strength";
+    })(exports.WaterpoloAdvantageTypes || (exports.WaterpoloAdvantageTypes = {}));
+    exports.WaterpoloGameLog = /** @class */ (function (_super) {
+        __extends(WaterpoloGameLog, _super);
+        function WaterpoloGameLog() {
+            var _this = _super.apply(this, __spreadArray([], __read(arguments))) || this;
+            _this.active = true;
+            return _this;
+        }
+        Object.defineProperty(WaterpoloGameLog.prototype, "penalizedGameUserId", {
+            get: function () {
+                if (this._penalizedGameUserId) {
+                    return this._penalizedGameUserId;
+                }
+                return this.gameUserId;
+            },
+            set: function (value) {
+                this._penalizedGameUserId = value;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        WaterpoloGameLog.prototype.compare = function (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;
+        };
+        Object.defineProperty(WaterpoloGameLog.prototype, "timeFormatted", {
+            get: function () {
+                var minutes = Math.floor(this.time / 60);
+                var seconds = this.time - minutes * 60;
+                return "" + (minutes < 10 ? '0' : '') + minutes + ":" + (seconds < 10 ? '0' : '') + seconds;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        WaterpoloGameLog.prototype.isScoreType = function () {
+            return [exports.WaterpoloGameLogTypes.goal, exports.WaterpoloGameLogTypes.shootout_goal, exports.WaterpoloGameLogTypes.after_game_shootout_goal].indexOf(this.logType) > -1;
+        };
+        WaterpoloGameLog.prototype.isPenaltyType = function () {
+            return [
+                exports.WaterpoloGameLogTypes.minor_penalty, exports.WaterpoloGameLogTypes.major_penalty, exports.WaterpoloGameLogTypes.match_penalty
+            ].indexOf(this.logType) > -1;
+        };
+        WaterpoloGameLog.prototype.isAfter = function (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;
+        };
+        WaterpoloGameLog.toFront = function (value) { };
+        WaterpoloGameLog.toBack = function (value) { };
+        return WaterpoloGameLog;
+    }(BaseModel));
+    __decorate([
+        ToFrontHook
+    ], exports.WaterpoloGameLog, "toFront", null);
+    __decorate([
+        ToBackHook
+    ], exports.WaterpoloGameLog, "toBack", null);
+    exports.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(exports.WaterpoloGameLogTypes),
+                advantage: enumField(exports.WaterpoloAdvantageTypes),
+            }
+        })
+    ], exports.WaterpoloGameLog);
+
+    exports.WaterpoloGameStatistic = /** @class */ (function (_super) {
+        __extends(WaterpoloGameStatistic, _super);
+        function WaterpoloGameStatistic() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        Object.defineProperty(WaterpoloGameStatistic.prototype, "id", {
+            get: function () {
+                return this.gameUserId;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(WaterpoloGameStatistic.prototype, "shotsOnGoal", {
+            get: function () {
+                return (this.evShotsOnGoal || 0) + (this.ppShotsOnGoal || 0) + (this.shShotsOnGoal || 0);
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(WaterpoloGameStatistic.prototype, "shotsBlocked", {
+            get: function () {
+                return (this.evShotsBlocked || 0) + (this.ppShotsBlocked || 0) + (this.shShotsBlocked || 0);
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(WaterpoloGameStatistic.prototype, "shotMisses", {
+            get: function () {
+                return (this.evShotMisses || 0) + (this.ppShotMisses || 0) + (this.shShotMisses || 0);
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(WaterpoloGameStatistic.prototype, "ppShots", {
+            get: function () {
+                return (this.ppShotMisses || 0) + (this.ppShotsOnGoal || 0) + (this.ppShotsBlocked || 0);
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(WaterpoloGameStatistic.prototype, "evShots", {
+            get: function () {
+                return (this.evShotMisses || 0) + (this.evShotsOnGoal || 0) + (this.evShotsBlocked || 0);
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(WaterpoloGameStatistic.prototype, "shShots", {
+            get: function () {
+                return (this.shShotMisses || 0) + (this.shShotsOnGoal || 0) + (this.shShotsBlocked || 0);
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(WaterpoloGameStatistic.prototype, "shots", {
+            get: function () {
+                return this.ppShots + this.evShots + this.shShots + (this.shootoutAttempts || 0);
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(WaterpoloGameStatistic.prototype, "totalShots", {
+            get: function () {
+                return this.shots + (this.shootoutAttempts || 0);
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(WaterpoloGameStatistic.prototype, "goals", {
+            get: function () {
+                return (this.ppGoals || 0) + (this.shGoals || 0) + (this.evGoals || 0);
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(WaterpoloGameStatistic.prototype, "totalGoals", {
+            get: function () {
+                return this.goals + (this.shootoutGoals || 0);
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(WaterpoloGameStatistic.prototype, "assists", {
+            get: function () {
+                return (this.ppAssists || 0) + (this.evAssists || 0) + (this.shAssists || 0);
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(WaterpoloGameStatistic.prototype, "faceOffs", {
+            get: function () {
+                return (this.faceOffWins || 0) + (this.faceOffLosses || 0);
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(WaterpoloGameStatistic.prototype, "shootOuts", {
+            get: function () {
+                return (this.shootoutAttempts || 0) + (this.shootoutGoals || 0);
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(WaterpoloGameStatistic.prototype, "shotsAgainst", {
+            get: function () {
+                return (this.saves || 0) + (this.goalsAgainst || 0);
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(WaterpoloGameStatistic.prototype, "shootoutShotsAgainst", {
+            get: function () {
+                return (this.shootoutSaves || 0) + (this.shootoutGoalsAgainst || 0);
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(WaterpoloGameStatistic.prototype, "totalShotsAgainst", {
+            get: function () {
+                return this.shotsAgainst + this.shootoutShotsAgainst;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(WaterpoloGameStatistic.prototype, "savesPercent", {
+            get: function () {
+                if (!this.shotsAgainst || !this.saves) {
+                    return 0;
+                }
+                return Math.round(1000 * this.saves / this.shotsAgainst) / 10;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(WaterpoloGameStatistic.prototype, "totalSaves", {
+            get: function () {
+                return (this.saves || 0) + (this.shootoutSaves || 0);
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(WaterpoloGameStatistic.prototype, "totalSavesPercent", {
+            get: function () {
+                if (!this.totalShotsAgainst || !this.totalSaves) {
+                    return 0;
+                }
+                return Math.round(1000 * this.totalSaves / this.totalShotsAgainst) / 10;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(WaterpoloGameStatistic.prototype, "totalGoalsAgainst", {
+            get: function () {
+                return (this.goalsAgainst || 0) + (this.shootoutGoalsAgainst || 0);
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(WaterpoloGameStatistic.prototype, "gameMinutes", {
+            get: function () {
+                return Math.floor(this.gameTime / 60);
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(WaterpoloGameStatistic.prototype, "goalsPercent", {
+            get: function () {
+                if (!this.totalGoals || !this.totalShots) {
+                    return 0;
+                }
+                return Math.round(1000 * this.totalGoals / this.totalShots) / 10;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(WaterpoloGameStatistic.prototype, "faceOffPercent", {
+            get: function () {
+                if (!this.faceOffWins || !this.faceOffs) {
+                    return 0;
+                }
+                return Math.round(1000 * this.faceOffWins / this.faceOffs) / 10;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(WaterpoloGameStatistic.prototype, "goalpass", {
+            get: function () {
+                return (this.totalGoals || 0) + (this.assists || 0);
+            },
+            enumerable: false,
+            configurable: true
+        });
+        WaterpoloGameStatistic.toFront = function (data) { };
+        WaterpoloGameStatistic.toBack = function (data) { };
+        return WaterpoloGameStatistic;
+    }(BaseModel));
+    __decorate([
+        ToFrontHook
+    ], exports.WaterpoloGameStatistic, "toFront", null);
+    __decorate([
+        ToBackHook
+    ], exports.WaterpoloGameStatistic, "toBack", null);
+    exports.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,
+            }
+        })
+    ], exports.WaterpoloGameStatistic);
+
+    exports.WaterpoloGameTeamStatistic = /** @class */ (function (_super) {
+        __extends(WaterpoloGameTeamStatistic, _super);
+        function WaterpoloGameTeamStatistic() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        WaterpoloGameTeamStatistic.toFront = function (data) { };
+        WaterpoloGameTeamStatistic.toBack = function (data) { };
+        return WaterpoloGameTeamStatistic;
+    }(BaseModel));
+    __decorate([
+        ToFrontHook
+    ], exports.WaterpoloGameTeamStatistic, "toFront", null);
+    __decorate([
+        ToBackHook
+    ], exports.WaterpoloGameTeamStatistic, "toBack", null);
+    exports.WaterpoloGameTeamStatistic = __decorate([
+        ModelInstance({
+            mappingFields: {
+                team: 'team',
+                competitor_team: 'competitorTeam'
+            },
+            relation: {
+                team: exports.WaterpoloStatistic,
+                competitorTeam: exports.WaterpoloStatistic
+            }
+        })
+    ], exports.WaterpoloGameTeamStatistic);
+
+    var WaterpoloGameApi = /** @class */ (function (_super) {
+        __extends(WaterpoloGameApi, _super);
+        function WaterpoloGameApi(httpClient, configService) {
+            var _this = _super.call(this, httpClient, configService) || this;
+            _this.httpClient = httpClient;
+            _this.configService = configService;
+            return _this;
+        }
+        WaterpoloGameApi.prototype.getById = function (gameId) {
+            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_waterpolo_game/" + gameId + "/").pipe(operators.map(function (result) { return exports.Game.toFront(result); })).toPromise()];
+                });
+            });
+        };
+        WaterpoloGameApi.prototype.getTeamStatistic = function (gameId) {
+            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_waterpolo_game/" + gameId + "/team_statistic/").pipe(operators.map(function (result) { return exports.WaterpoloGameTeamStatistic.toFront(result); })).toPromise()];
+                });
+            });
+        };
+        WaterpoloGameApi.prototype.getUserStatistic = function (gameId) {
+            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_waterpolo_game/" + gameId + "/user_statistic/").pipe(operators.map(function (result) { return exports.WaterpoloGameStatistic.toFront(result); })).toPromise()];
+                });
+            });
+        };
+        WaterpoloGameApi.prototype.getLogs = function (gameId) {
+            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_waterpolo_game/" + gameId + "/logs/").pipe(operators.map(function (result) { return exports.WaterpoloGameLog.toFront(result); })).toPromise()];
+                });
+            });
+        };
+        WaterpoloGameApi.prototype.downloadProtocol = function (gameId, format) {
+            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_waterpolo_game/" + gameId + "/game_protocol/", {
+                            params: new i1.HttpParams().set('file_type', format),
+                            responseType: 'blob'
+                        }).toPromise()];
+                });
+            });
+        };
+        WaterpoloGameApi.prototype.downloadApplication = function (gameId, format, type) {
+            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_waterpolo_game/" + gameId + "/game_application_file/", {
+                            params: new i1.HttpParams().set('file_type', format).set('application_type', type),
+                            responseType: 'blob'
+                        }).toPromise()];
+                });
+            });
+        };
+        return WaterpoloGameApi;
+    }(GameBaseApi));
+    WaterpoloGameApi.ɵprov = i0__namespace.ɵɵdefineInjectable({ factory: function WaterpoloGameApi_Factory() { return new WaterpoloGameApi(i0__namespace.ɵɵinject(i1__namespace.HttpClient), i0__namespace.ɵɵinject(ConfigService)); }, token: WaterpoloGameApi, providedIn: "root" });
+    WaterpoloGameApi.decorators = [
+        { type: i0.Injectable, args: [{ providedIn: 'root' },] }
+    ];
+    WaterpoloGameApi.ctorParameters = function () { return [
+        { type: i1.HttpClient },
+        { type: ConfigService }
+    ]; };
+
     var PublicTeamApi = /** @class */ (function () {
         function PublicTeamApi(httpClient, configService) {
             this.httpClient = httpClient;
@@ -10031,148 +10850,182 @@
         { type: ConfigService }
     ]; };
 
-    var _a$d;
-    var BasketballGameLogTypeLocalization = (_a$d = {},
-        _a$d[exports.BasketballGameLogTypes.enter_game] = 'Выход на площадку',
-        _a$d[exports.BasketballGameLogTypes.exit_game] = 'Ушел с площадки',
-        _a$d[exports.BasketballGameLogTypes.remove_game] = 'Удаление с площадки',
-        _a$d[exports.BasketballGameLogTypes.two_point_attempt] = 'Бросок 2 очка',
-        _a$d[exports.BasketballGameLogTypes.three_point_attempt] = 'Бросок 3 очка',
-        _a$d[exports.BasketballGameLogTypes.free_throw_attempt] = 'Штрафной бросок',
-        _a$d[exports.BasketballGameLogTypes.one_point_attempt] = 'Бросок 1 очко',
-        _a$d[exports.BasketballGameLogTypes.two_point_made] = '2 очка',
-        _a$d[exports.BasketballGameLogTypes.three_point_made] = '3 очка',
-        _a$d[exports.BasketballGameLogTypes.free_throw_made] = '1 очко, штрафной',
-        _a$d[exports.BasketballGameLogTypes.one_point_made] = '1 очко',
-        _a$d[exports.BasketballGameLogTypes.assist] = 'Передача',
-        _a$d[exports.BasketballGameLogTypes.block] = 'Блокшот',
-        _a$d[exports.BasketballGameLogTypes.rebound] = 'Подбор',
-        _a$d[exports.BasketballGameLogTypes.offensive_rebound] = 'Подбор в нападении',
-        _a$d[exports.BasketballGameLogTypes.defensive_rebound] = 'Подбор в защите',
-        _a$d[exports.BasketballGameLogTypes.steal] = 'Перехват',
-        _a$d[exports.BasketballGameLogTypes.turnover] = 'Потеря',
-        _a$d[exports.BasketballGameLogTypes.personal_foul] = 'Фол',
-        _a$d[exports.BasketballGameLogTypes.technical_foul] = 'Технический фол',
-        _a$d[exports.BasketballGameLogTypes.unsportsmanlike_foul] = 'Неспортиный фол',
-        _a$d[exports.BasketballGameLogTypes.timeout] = 'Таймаут',
-        _a$d[exports.BasketballGameLogTypes.team_rebound] = 'Командный подбор',
-        _a$d);
+    var _a$e;
+    var BasketballGameLogTypeLocalization = (_a$e = {},
+        _a$e[exports.BasketballGameLogTypes.enter_game] = 'Выход на площадку',
+        _a$e[exports.BasketballGameLogTypes.exit_game] = 'Ушел с площадки',
+        _a$e[exports.BasketballGameLogTypes.remove_game] = 'Удаление с площадки',
+        _a$e[exports.BasketballGameLogTypes.two_point_attempt] = 'Бросок 2 очка',
+        _a$e[exports.BasketballGameLogTypes.three_point_attempt] = 'Бросок 3 очка',
+        _a$e[exports.BasketballGameLogTypes.free_throw_attempt] = 'Штрафной бросок',
+        _a$e[exports.BasketballGameLogTypes.one_point_attempt] = 'Бросок 1 очко',
+        _a$e[exports.BasketballGameLogTypes.two_point_made] = '2 очка',
+        _a$e[exports.BasketballGameLogTypes.three_point_made] = '3 очка',
+        _a$e[exports.BasketballGameLogTypes.free_throw_made] = '1 очко, штрафной',
+        _a$e[exports.BasketballGameLogTypes.one_point_made] = '1 очко',
+        _a$e[exports.BasketballGameLogTypes.assist] = 'Передача',
+        _a$e[exports.BasketballGameLogTypes.block] = 'Блокшот',
+        _a$e[exports.BasketballGameLogTypes.rebound] = 'Подбор',
+        _a$e[exports.BasketballGameLogTypes.offensive_rebound] = 'Подбор в нападении',
+        _a$e[exports.BasketballGameLogTypes.defensive_rebound] = 'Подбор в защите',
+        _a$e[exports.BasketballGameLogTypes.steal] = 'Перехват',
+        _a$e[exports.BasketballGameLogTypes.turnover] = 'Потеря',
+        _a$e[exports.BasketballGameLogTypes.personal_foul] = 'Фол',
+        _a$e[exports.BasketballGameLogTypes.technical_foul] = 'Технический фол',
+        _a$e[exports.BasketballGameLogTypes.unsportsmanlike_foul] = 'Неспортиный фол',
+        _a$e[exports.BasketballGameLogTypes.timeout] = 'Таймаут',
+        _a$e[exports.BasketballGameLogTypes.team_rebound] = 'Командный подбор',
+        _a$e);
 
-    var _a$c;
-    var BasketballGameSubLogTypesLocalization = (_a$c = {},
+    var _a$d;
+    var BasketballGameSubLogTypesLocalization = (_a$d = {},
         // Shots
-        _a$c[exports.BasketballSubLogTypes.jump_shot] = 'Джампшот',
-        _a$c[exports.BasketballSubLogTypes.step_back_jump_shot] = 'Степ-бэк',
-        _a$c[exports.BasketballSubLogTypes.floating_jump_shot] = 'Флоатинг',
-        _a$c[exports.BasketballSubLogTypes.fade_away_jump_shot] = 'Фэйдавэй',
-        _a$c[exports.BasketballSubLogTypes.pull_up_jump_shot] = 'Пуллап',
-        _a$c[exports.BasketballSubLogTypes.turnaround_jump_shot] = 'Турнэраунд',
-        _a$c[exports.BasketballSubLogTypes.dunk] = 'Данк',
-        _a$c[exports.BasketballSubLogTypes.layup] = 'Лэйап',
-        _a$c[exports.BasketballSubLogTypes.driving_layup] = 'Драйвинг лэйап',
-        _a$c[exports.BasketballSubLogTypes.alley_oop] = 'Алейуп',
-        _a$c[exports.BasketballSubLogTypes.hook_shot] = 'Хукшот',
+        _a$d[exports.BasketballSubLogTypes.jump_shot] = 'Джампшот',
+        _a$d[exports.BasketballSubLogTypes.step_back_jump_shot] = 'Степ-бэк',
+        _a$d[exports.BasketballSubLogTypes.floating_jump_shot] = 'Флоатинг',
+        _a$d[exports.BasketballSubLogTypes.fade_away_jump_shot] = 'Фэйдавэй',
+        _a$d[exports.BasketballSubLogTypes.pull_up_jump_shot] = 'Пуллап',
+        _a$d[exports.BasketballSubLogTypes.turnaround_jump_shot] = 'Турнэраунд',
+        _a$d[exports.BasketballSubLogTypes.dunk] = 'Данк',
+        _a$d[exports.BasketballSubLogTypes.layup] = 'Лэйап',
+        _a$d[exports.BasketballSubLogTypes.driving_layup] = 'Драйвинг лэйап',
+        _a$d[exports.BasketballSubLogTypes.alley_oop] = 'Алейуп',
+        _a$d[exports.BasketballSubLogTypes.hook_shot] = 'Хукшот',
         // foul
-        _a$c[exports.BasketballSubLogTypes.offensive_foul] = 'В нападении',
-        _a$c[exports.BasketballSubLogTypes.shot_foul] = 'При броксе',
-        _a$c[exports.BasketballSubLogTypes.mutual_foul] = 'Обоюдный фол',
+        _a$d[exports.BasketballSubLogTypes.offensive_foul] = 'В нападении',
+        _a$d[exports.BasketballSubLogTypes.shot_foul] = 'При броксе',
+        _a$d[exports.BasketballSubLogTypes.mutual_foul] = 'Обоюдный фол',
         // Turnover
-        _a$c[exports.BasketballSubLogTypes.bad_pass] = 'Плохой пас',
-        _a$c[exports.BasketballSubLogTypes.ball_handling] = 'На ведении',
-        _a$c[exports.BasketballSubLogTypes.travel] = 'Пробежка',
-        _a$c[exports.BasketballSubLogTypes.double_dribble] = 'Двойная пробежка',
-        _a$c[exports.BasketballSubLogTypes.out_of_bounds] = 'Заступ в аут',
-        _a$c[exports.BasketballSubLogTypes.three_seconds] = '3 секунды',
-        _a$c[exports.BasketballSubLogTypes.five_seconds] = '5 секунд',
-        _a$c[exports.BasketballSubLogTypes.eight_seconds] = '8 секунд',
-        _a$c[exports.BasketballSubLogTypes.twenty_four_seconds] = '24 секунды',
+        _a$d[exports.BasketballSubLogTypes.bad_pass] = 'Плохой пас',
+        _a$d[exports.BasketballSubLogTypes.ball_handling] = 'На ведении',
+        _a$d[exports.BasketballSubLogTypes.travel] = 'Пробежка',
+        _a$d[exports.BasketballSubLogTypes.double_dribble] = 'Двойная пробежка',
+        _a$d[exports.BasketballSubLogTypes.out_of_bounds] = 'Заступ в аут',
+        _a$d[exports.BasketballSubLogTypes.three_seconds] = '3 секунды',
+        _a$d[exports.BasketballSubLogTypes.five_seconds] = '5 секунд',
+        _a$d[exports.BasketballSubLogTypes.eight_seconds] = '8 секунд',
+        _a$d[exports.BasketballSubLogTypes.twenty_four_seconds] = '24 секунды',
+        _a$d);
+
+    var _a$c;
+    var HockeyGameLogTypeLocalization = (_a$c = {},
+        _a$c[exports.HockeyGameLogTypes.enter_game] = 'Выход на площадку',
+        _a$c[exports.HockeyGameLogTypes.exit_game] = 'Ушел с площадки',
+        _a$c[exports.HockeyGameLogTypes.shot_miss] = 'Бросок мимо',
+        _a$c[exports.HockeyGameLogTypes.shot_on_goal] = 'Бросок по воротам',
+        _a$c[exports.HockeyGameLogTypes.shot_blocked] = 'Заблокированный бросок',
+        _a$c[exports.HockeyGameLogTypes.goal] = 'Гол',
+        _a$c[exports.HockeyGameLogTypes.shootout_attempt] = 'Буллит промах',
+        _a$c[exports.HockeyGameLogTypes.shootout_goal] = 'Буллит гол',
+        _a$c[exports.HockeyGameLogTypes.after_game_shootout_attempt] = 'Буллит промах',
+        _a$c[exports.HockeyGameLogTypes.after_game_shootout_goal] = 'Буллит гол',
+        _a$c[exports.HockeyGameLogTypes.assist] = 'Передача',
+        _a$c[exports.HockeyGameLogTypes.block_shot] = 'Блокировка броска',
+        _a$c[exports.HockeyGameLogTypes.minor_penalty] = 'Малый штраф',
+        _a$c[exports.HockeyGameLogTypes.major_penalty] = 'Большой штраф',
+        _a$c[exports.HockeyGameLogTypes.misconduct_penalty] = 'Дисциплинарный штраф',
+        _a$c[exports.HockeyGameLogTypes.game_misconduct_penalty] = 'Дисциплинарный штраф до конца игры',
+        _a$c[exports.HockeyGameLogTypes.match_penalty] = 'Матч-штраф',
+        _a$c[exports.HockeyGameLogTypes.penalty_shot] = 'Штрафной бросок',
+        _a$c[exports.HockeyGameLogTypes.face_off_lose] = 'Проигрыш в вбрасывании',
+        _a$c[exports.HockeyGameLogTypes.face_off_win] = 'Победа в вбрасывании',
+        _a$c[exports.HockeyGameLogTypes.save] = 'Отражен бросок',
+        _a$c[exports.HockeyGameLogTypes.shootout_save] = 'Отражен бросок',
+        _a$c[exports.HockeyGameLogTypes.after_game_shootout_save] = 'Отражен бросок',
+        _a$c[exports.HockeyGameLogTypes.timeout] = 'Таймаут',
+        _a$c[exports.HockeyGameLogTypes.penalty_start] = 'Начало штрафного времени',
+        _a$c[exports.HockeyGameLogTypes.penalty_end] = 'Конец штрафного времени',
         _a$c);
 
     var _a$b;
-    var HockeyGameLogTypeLocalization = (_a$b = {},
-        _a$b[exports.HockeyGameLogTypes.enter_game] = 'Выход на площадку',
-        _a$b[exports.HockeyGameLogTypes.exit_game] = 'Ушел с площадки',
-        _a$b[exports.HockeyGameLogTypes.shot_miss] = 'Бросок мимо',
-        _a$b[exports.HockeyGameLogTypes.shot_on_goal] = 'Бросок по воротам',
-        _a$b[exports.HockeyGameLogTypes.shot_blocked] = 'Заблокированный бросок',
-        _a$b[exports.HockeyGameLogTypes.goal] = 'Гол',
-        _a$b[exports.HockeyGameLogTypes.shootout_attempt] = 'Буллит промах',
-        _a$b[exports.HockeyGameLogTypes.shootout_goal] = 'Буллит гол',
-        _a$b[exports.HockeyGameLogTypes.after_game_shootout_attempt] = 'Буллит промах',
-        _a$b[exports.HockeyGameLogTypes.after_game_shootout_goal] = 'Буллит гол',
-        _a$b[exports.HockeyGameLogTypes.assist] = 'Передача',
-        _a$b[exports.HockeyGameLogTypes.block_shot] = 'Блокировка броска',
-        _a$b[exports.HockeyGameLogTypes.minor_penalty] = 'Малый штраф',
-        _a$b[exports.HockeyGameLogTypes.major_penalty] = 'Большой штраф',
-        _a$b[exports.HockeyGameLogTypes.misconduct_penalty] = 'Дисциплинарный штраф',
-        _a$b[exports.HockeyGameLogTypes.game_misconduct_penalty] = 'Дисциплинарный штраф до конца игры',
-        _a$b[exports.HockeyGameLogTypes.match_penalty] = 'Матч-штраф',
-        _a$b[exports.HockeyGameLogTypes.penalty_shot] = 'Штрафной бросок',
-        _a$b[exports.HockeyGameLogTypes.face_off_lose] = 'Проигрыш в вбрасывании',
-        _a$b[exports.HockeyGameLogTypes.face_off_win] = 'Победа в вбрасывании',
-        _a$b[exports.HockeyGameLogTypes.save] = 'Отражен бросок',
-        _a$b[exports.HockeyGameLogTypes.shootout_save] = 'Отражен бросок',
-        _a$b[exports.HockeyGameLogTypes.after_game_shootout_save] = 'Отражен бросок',
-        _a$b[exports.HockeyGameLogTypes.timeout] = 'Таймаут',
-        _a$b[exports.HockeyGameLogTypes.penalty_start] = 'Начало штрафного времени',
-        _a$b[exports.HockeyGameLogTypes.penalty_end] = 'Конец штрафного времени',
+    var FootballGameLogTypeLocalization = (_a$b = {},
+        _a$b[exports.FootballGameLogTypes.enter_game] = 'Выход на поле',
+        _a$b[exports.FootballGameLogTypes.exit_game] = 'Ушел с поля',
+        _a$b[exports.FootballGameLogTypes.shot_miss] = 'Удар мимо',
+        _a$b[exports.FootballGameLogTypes.shot_on_goal] = 'Удар в створ',
+        _a$b[exports.FootballGameLogTypes.shot_blocked] = 'Заблокированный удар',
+        _a$b[exports.FootballGameLogTypes.goal] = 'Гол',
+        _a$b[exports.FootballGameLogTypes.assist] = 'Передача',
+        _a$b[exports.FootballGameLogTypes.penalty_attempt] = 'Пенальти промах',
+        _a$b[exports.FootballGameLogTypes.penalty_goal] = 'Пенальти гол',
+        _a$b[exports.FootballGameLogTypes.small_penalty_attempt] = '10-метровый промах',
+        _a$b[exports.FootballGameLogTypes.small_penalty_goal] = '10-метровый гол',
+        _a$b[exports.FootballGameLogTypes.block_shot] = 'Блокировка удара',
+        _a$b[exports.FootballGameLogTypes.corner] = 'Угловой',
+        _a$b[exports.FootballGameLogTypes.free_kick] = 'Штрафной удар',
+        _a$b[exports.FootballGameLogTypes.save] = 'Отражен удар',
+        _a$b[exports.FootballGameLogTypes.penalty_save] = 'Отражен пенальти',
+        _a$b[exports.FootballGameLogTypes.small_penalty_save] = 'Отражен 10 метровый',
+        _a$b[exports.FootballGameLogTypes.foul] = 'Фол',
+        _a$b[exports.FootballGameLogTypes.yellow_card] = 'Желтая карточка',
+        _a$b[exports.FootballGameLogTypes.red_card] = 'Красная карточка',
+        _a$b[exports.FootballGameLogTypes.perfect_pass] = 'Пас',
+        _a$b[exports.FootballGameLogTypes.loss] = 'Потеря',
+        _a$b[exports.FootballGameLogTypes.steal] = 'Перехват',
+        _a$b[exports.FootballGameLogTypes.out] = 'Аут',
+        _a$b[exports.FootballGameLogTypes.timeout] = 'Таймаут',
+        _a$b[exports.FootballGameLogTypes.auto_goal] = 'Автогол',
+        _a$b[exports.FootballGameLogTypes.end_game_penalty_goal] = 'Пенальти гол',
+        _a$b[exports.FootballGameLogTypes.end_game_penalty_miss] = 'Пенальти промах',
+        _a$b[exports.FootballGameLogTypes.end_game_penalty_save] = 'Отражен пенальти',
         _a$b);
 
     var _a$a;
-    var FootballGameLogTypeLocalization = (_a$a = {},
-        _a$a[exports.FootballGameLogTypes.enter_game] = 'Выход на поле',
-        _a$a[exports.FootballGameLogTypes.exit_game] = 'Ушел с поля',
-        _a$a[exports.FootballGameLogTypes.shot_miss] = 'Удар мимо',
-        _a$a[exports.FootballGameLogTypes.shot_on_goal] = 'Удар в створ',
-        _a$a[exports.FootballGameLogTypes.shot_blocked] = 'Заблокированный удар',
-        _a$a[exports.FootballGameLogTypes.goal] = 'Гол',
-        _a$a[exports.FootballGameLogTypes.assist] = 'Передача',
-        _a$a[exports.FootballGameLogTypes.penalty_attempt] = 'Пенальти промах',
-        _a$a[exports.FootballGameLogTypes.penalty_goal] = 'Пенальти гол',
-        _a$a[exports.FootballGameLogTypes.small_penalty_attempt] = '10-метровый промах',
-        _a$a[exports.FootballGameLogTypes.small_penalty_goal] = '10-метровый гол',
-        _a$a[exports.FootballGameLogTypes.block_shot] = 'Блокировка удара',
-        _a$a[exports.FootballGameLogTypes.corner] = 'Угловой',
-        _a$a[exports.FootballGameLogTypes.free_kick] = 'Штрафной удар',
-        _a$a[exports.FootballGameLogTypes.save] = 'Отражен удар',
-        _a$a[exports.FootballGameLogTypes.penalty_save] = 'Отражен пенальти',
-        _a$a[exports.FootballGameLogTypes.small_penalty_save] = 'Отражен 10 метровый',
-        _a$a[exports.FootballGameLogTypes.foul] = 'Фол',
-        _a$a[exports.FootballGameLogTypes.yellow_card] = 'Желтая карточка',
-        _a$a[exports.FootballGameLogTypes.red_card] = 'Красная карточка',
-        _a$a[exports.FootballGameLogTypes.perfect_pass] = 'Пас',
-        _a$a[exports.FootballGameLogTypes.loss] = 'Потеря',
-        _a$a[exports.FootballGameLogTypes.steal] = 'Перехват',
-        _a$a[exports.FootballGameLogTypes.out] = 'Аут',
-        _a$a[exports.FootballGameLogTypes.timeout] = 'Таймаут',
-        _a$a[exports.FootballGameLogTypes.auto_goal] = 'Автогол',
-        _a$a[exports.FootballGameLogTypes.end_game_penalty_goal] = 'Пенальти гол',
-        _a$a[exports.FootballGameLogTypes.end_game_penalty_miss] = 'Пенальти промах',
-        _a$a[exports.FootballGameLogTypes.end_game_penalty_save] = 'Отражен пенальти',
+    var HandballGameLogTypeLocalization = (_a$a = {},
+        _a$a[exports.HandballGameLogTypes.enter_game] = 'Выход на поле',
+        _a$a[exports.HandballGameLogTypes.exit_game] = 'Ушел с поля',
+        _a$a[exports.HandballGameLogTypes.shot_miss] = 'Бросок мимо',
+        _a$a[exports.HandballGameLogTypes.shot_on_goal] = 'Бросок в створ',
+        _a$a[exports.HandballGameLogTypes.shot_blocked] = 'Заблокированный бросок',
+        _a$a[exports.HandballGameLogTypes.goal] = 'Гол',
+        _a$a[exports.HandballGameLogTypes.assist] = 'Передача',
+        _a$a[exports.HandballGameLogTypes.penalty_miss] = '7м промах',
+        _a$a[exports.HandballGameLogTypes.penalty_shot_on_goal] = '7м в створ',
+        _a$a[exports.HandballGameLogTypes.penalty_goal] = '7м гол',
+        _a$a[exports.HandballGameLogTypes.save] = 'Сэйв',
+        _a$a[exports.HandballGameLogTypes.penalty_save] = 'Сэйв 7м',
+        _a$a[exports.HandballGameLogTypes.foul] = 'Фол',
+        _a$a[exports.HandballGameLogTypes.yellow_card] = 'Желлтая карточка',
+        _a$a[exports.HandballGameLogTypes.red_card] = 'Красная карточка',
+        _a$a[exports.HandballGameLogTypes.two_minute_foul] = '2х минутный штраф',
+        _a$a[exports.HandballGameLogTypes.turnover] = 'Потеря',
+        _a$a[exports.HandballGameLogTypes.steal] = 'Перехват',
+        _a$a[exports.HandballGameLogTypes.block_shot] = 'Блок броска',
+        _a$a[exports.HandballGameLogTypes.timeout] = 'Таймаут',
         _a$a);
 
     var _a$9;
-    var HandballGameLogTypeLocalization = (_a$9 = {},
-        _a$9[exports.HandballGameLogTypes.enter_game] = 'Выход на поле',
-        _a$9[exports.HandballGameLogTypes.exit_game] = 'Ушел с поля',
-        _a$9[exports.HandballGameLogTypes.shot_miss] = 'Бросок мимо',
-        _a$9[exports.HandballGameLogTypes.shot_on_goal] = 'Бросок в створ',
-        _a$9[exports.HandballGameLogTypes.shot_blocked] = 'Заблокированный бросок',
-        _a$9[exports.HandballGameLogTypes.goal] = 'Гол',
-        _a$9[exports.HandballGameLogTypes.assist] = 'Передача',
-        _a$9[exports.HandballGameLogTypes.penalty_miss] = '7м промах',
-        _a$9[exports.HandballGameLogTypes.penalty_shot_on_goal] = '7м в створ',
-        _a$9[exports.HandballGameLogTypes.penalty_goal] = '7м гол',
-        _a$9[exports.HandballGameLogTypes.save] = 'Сэйв',
-        _a$9[exports.HandballGameLogTypes.penalty_save] = 'Сэйв 7м',
-        _a$9[exports.HandballGameLogTypes.foul] = 'Фол',
-        _a$9[exports.HandballGameLogTypes.yellow_card] = 'Желлтая карточка',
-        _a$9[exports.HandballGameLogTypes.red_card] = 'Красная карточка',
-        _a$9[exports.HandballGameLogTypes.two_minute_foul] = '2х минутный штраф',
-        _a$9[exports.HandballGameLogTypes.turnover] = 'Потеря',
-        _a$9[exports.HandballGameLogTypes.steal] = 'Перехват',
-        _a$9[exports.HandballGameLogTypes.block_shot] = 'Блок броска',
-        _a$9[exports.HandballGameLogTypes.timeout] = 'Таймаут',
+    var WaterpoloGameLogTypeLocalization = (_a$9 = {},
+        _a$9[exports.WaterpoloGameLogTypes.enter_game] = 'Выход на площадку',
+        _a$9[exports.WaterpoloGameLogTypes.exit_game] = 'Ушел с площадки',
+        _a$9[exports.WaterpoloGameLogTypes.shot_miss] = 'Бросок мимо',
+        _a$9[exports.WaterpoloGameLogTypes.shot_on_goal] = 'Бросок по воротам',
+        _a$9[exports.WaterpoloGameLogTypes.shot_blocked] = 'Заблокированный бросок',
+        _a$9[exports.WaterpoloGameLogTypes.goal] = 'Гол',
+        _a$9[exports.WaterpoloGameLogTypes.shootout_attempt] = 'Пенальти промах',
+        _a$9[exports.WaterpoloGameLogTypes.shootout_goal] = 'Пенальти гол',
+        _a$9[exports.WaterpoloGameLogTypes.after_game_shootout_attempt] = 'Пенальти промах',
+        _a$9[exports.WaterpoloGameLogTypes.after_game_shootout_goal] = 'Пенальти гол',
+        _a$9[exports.WaterpoloGameLogTypes.assist] = 'Передача',
+        _a$9[exports.WaterpoloGameLogTypes.block_shot] = 'Блокировка броска',
+        _a$9[exports.WaterpoloGameLogTypes.minor_penalty] = 'Штраф 20 сек.',
+        _a$9[exports.WaterpoloGameLogTypes.major_penalty] = 'Штраф 4 мин.',
+        _a$9[exports.WaterpoloGameLogTypes.match_penalty] = 'Матч-штраф',
+        _a$9[exports.WaterpoloGameLogTypes.foul] = 'Фол',
+        _a$9[exports.WaterpoloGameLogTypes.penalty_shot] = 'Штрафной бросок',
+        _a$9[exports.WaterpoloGameLogTypes.face_off_lose] = 'Проигрыш в спринте',
+        _a$9[exports.WaterpoloGameLogTypes.face_off_win] = 'Победа в спринте',
+        _a$9[exports.WaterpoloGameLogTypes.save] = 'Отражен бросок',
+        _a$9[exports.WaterpoloGameLogTypes.shootout_save] = 'Отражен бросок',
+        _a$9[exports.WaterpoloGameLogTypes.after_game_shootout_save] = 'Отражен бросок',
+        _a$9[exports.WaterpoloGameLogTypes.timeout] = 'Таймаут',
+        _a$9[exports.WaterpoloGameLogTypes.penalty_start] = 'Начало штрафного времени',
+        _a$9[exports.WaterpoloGameLogTypes.penalty_end] = 'Конец штрафного времени',
+        _a$9[exports.WaterpoloGameLogTypes.yellow_card] = 'Желтая карточка',
+        _a$9[exports.WaterpoloGameLogTypes.red_card] = 'Красная карточка',
+        _a$9[exports.WaterpoloGameLogTypes.free_kick] = 'Свободный удар',
+        _a$9[exports.WaterpoloGameLogTypes.loss] = 'Потеря',
+        _a$9[exports.WaterpoloGameLogTypes.steal] = 'Перехват',
         _a$9);
 
     var _a$8;
@@ -10252,7 +11105,7 @@
         _a$5[exports.TeamUserRole.assistant] = 'Ассистент',
         _a$5);
 
-    var _a$4, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+    var _a$4, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
     var GameBasketballPositionLocalization = (_a$4 = {},
         _a$4[exports.GameBasketballPosition.point_guard] = 'Разыгрывающий защитник',
         _a$4[exports.GameBasketballPosition.shooting_guard] = 'Атакующий защитник',
@@ -10331,6 +11184,22 @@
         _o[exports.GameRugbyPosition.three_quarter] = 'Трехчетвертный',
         _o[exports.GameRugbyPosition.fullback] = 'Замыкающий',
         _o);
+    var GameWaterpoloPositionLocalization = (_p = {},
+        _p[exports.GameWaterpoloPosition.defensemen] = 'Защитник',
+        _p[exports.GameWaterpoloPosition.goalkeeper] = 'Вратарь',
+        _p[exports.GameWaterpoloPosition.center_forward] = 'Центральный нападающий',
+        _p[exports.GameWaterpoloPosition.mobile_forward] = 'Подвижный нападающий',
+        _p);
+    var GameWaterpoloPositionShortRuLocalization = (_q = {},
+        _q[exports.GameWaterpoloPosition.defensemen] = 'З',
+        _q[exports.GameWaterpoloPosition.goalkeeper] = 'Вр',
+        _q[exports.GameWaterpoloPosition.center_forward] = 'ЦН',
+        _q[exports.GameWaterpoloPosition.mobile_forward] = 'ПН',
+        _q);
+    var WaterpoloWorkHandLocalization = (_r = {},
+        _r[exports.WaterpoloWorkHand.left] = 'Левая',
+        _r[exports.WaterpoloWorkHand.right] = 'Правая',
+        _r);
 
     var _a$3;
     var VolleyballGameLogTypeLocalization = (_a$3 = {},
@@ -11018,6 +11887,8 @@
     exports.GameVolleyballPositionLocalization = GameVolleyballPositionLocalization;
     exports.GameVolleyballPositionShortLocalization = GameVolleyballPositionShortLocalization;
     exports.GameVolleyballPositionShortRuLocalization = GameVolleyballPositionShortRuLocalization;
+    exports.GameWaterpoloPositionLocalization = GameWaterpoloPositionLocalization;
+    exports.GameWaterpoloPositionShortRuLocalization = GameWaterpoloPositionShortRuLocalization;
     exports.HandballGameApi = HandballGameApi;
     exports.HandballGameLogTypeLocalization = HandballGameLogTypeLocalization;
     exports.HockeyGameApi = HockeyGameApi;
@@ -11069,6 +11940,9 @@
     exports.VolleyballGameApi = VolleyballGameApi;
     exports.VolleyballGameLogTypeLocalization = VolleyballGameLogTypeLocalization;
     exports.VolleyballWorkHandLocalization = VolleyballWorkHandLocalization;
+    exports.WaterpoloGameApi = WaterpoloGameApi;
+    exports.WaterpoloGameLogTypeLocalization = WaterpoloGameLogTypeLocalization;
+    exports.WaterpoloWorkHandLocalization = WaterpoloWorkHandLocalization;
     exports.WorkHandLocalization = WorkHandLocalization;
     exports.addItemInArray = addItemInArray;
     exports.addItemsInArray = addItemsInArray;