@mtgame/core 0.1.57 → 0.1.59

package/fesm2015/mtgame-core.js

@@ -1,5 +1,7 @@
-import { __decorate, __param, __awaiter } from 'tslib';
-import { ɵɵdefineInjectable, Injectable, Optional, Inject, ɵɵinject, Injector, PLATFORM_ID } from '@angular/core';
+import { __decorate, __awaiter } from 'tslib';
+import * as i0 from '@angular/core';
+import { Injectable, Optional, Inject, Injector, PLATFORM_ID } from '@angular/core';
+import * as i1 from '@angular/common/http';
 import { HttpParams, HttpClient } from '@angular/common/http';
 import { filter, map, delay, switchMap } from 'rxjs/operators';
 import { BehaviorSubject, Observable, of } from 'rxjs';
@@ -1919,22 +1921,22 @@ class Store {
     }
 }
 
-let BaseService = class BaseService {
+class BaseService {
     constructor() {
         this.store = new Store();
     }
     dispose() {
         this.store.dispose();
     }
-};
-BaseService.ɵprov = ɵɵdefineInjectable({ factory: function BaseService_Factory() { return new BaseService(); }, token: BaseService, providedIn: "root" });
-BaseService = __decorate([
-    Injectable({ providedIn: 'root' })
-], BaseService);
+}
+BaseService.ɵprov = i0.ɵɵdefineInjectable({ factory: function BaseService_Factory() { return new BaseService(); }, token: BaseService, providedIn: "root" });
+BaseService.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
 
 const CONFIG_STORE_KEY = 'config';
 const CONFIG_DATA = 'mtg-core-config-data';
-let ConfigService = class ConfigService extends BaseService {
+class ConfigService extends BaseService {
     constructor(configData) {
         super();
         this.configData = configData;
@@ -1957,15 +1959,14 @@ let ConfigService = class ConfigService extends BaseService {
     get(key) {
         return this.store.value(CONFIG_STORE_KEY) && this.store.value(CONFIG_STORE_KEY)[key];
     }
-};
+}
+ConfigService.ɵprov = i0.ɵɵdefineInjectable({ factory: function ConfigService_Factory() { return new ConfigService(i0.ɵɵinject("mtg-core-config-data", 8)); }, token: ConfigService, providedIn: "root" });
+ConfigService.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
 ConfigService.ctorParameters = () => [
     { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [CONFIG_DATA,] }] }
 ];
-ConfigService.ɵprov = ɵɵdefineInjectable({ factory: function ConfigService_Factory() { return new ConfigService(ɵɵinject("mtg-core-config-data", 8)); }, token: ConfigService, providedIn: "root" });
-ConfigService = __decorate([
-    Injectable({ providedIn: 'root' }),
-    __param(0, Optional()), __param(0, Inject(CONFIG_DATA))
-], ConfigService);
 
 let TournamentTeam = class TournamentTeam extends BaseModel {
     get gamesWonPercent() {
@@ -2500,7 +2501,7 @@ GameUserLimitations = __decorate([
     })
 ], GameUserLimitations);
 
-let GameBaseApi = class GameBaseApi {
+class GameBaseApi {
     constructor(httpClient, configService) {
         this.httpClient = httpClient;
         this.configService = configService;
@@ -2528,17 +2529,17 @@ let GameBaseApi = class GameBaseApi {
             }).toPromise();
         });
     }
-};
+}
+GameBaseApi.ɵprov = i0.ɵɵdefineInjectable({ factory: function GameBaseApi_Factory() { return new GameBaseApi(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(ConfigService)); }, token: GameBaseApi, providedIn: "root" });
+GameBaseApi.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
 GameBaseApi.ctorParameters = () => [
     { type: HttpClient },
     { type: ConfigService }
 ];
-GameBaseApi.ɵprov = ɵɵdefineInjectable({ factory: function GameBaseApi_Factory() { return new GameBaseApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: GameBaseApi, providedIn: "root" });
-GameBaseApi = __decorate([
-    Injectable({ providedIn: 'root' })
-], GameBaseApi);
 
-let BasketballGameApi = class BasketballGameApi extends GameBaseApi {
+class BasketballGameApi extends GameBaseApi {
     constructor(httpClient, configService) {
         super(httpClient, configService);
         this.httpClient = httpClient;
@@ -2576,15 +2577,15 @@ let BasketballGameApi = class BasketballGameApi extends GameBaseApi {
                 .toPromise();
         });
     }
-};
+}
+BasketballGameApi.ɵprov = i0.ɵɵdefineInjectable({ factory: function BasketballGameApi_Factory() { return new BasketballGameApi(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(ConfigService)); }, token: BasketballGameApi, providedIn: "root" });
+BasketballGameApi.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
 BasketballGameApi.ctorParameters = () => [
     { type: HttpClient },
     { type: ConfigService }
 ];
-BasketballGameApi.ɵprov = ɵɵdefineInjectable({ factory: function BasketballGameApi_Factory() { return new BasketballGameApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: BasketballGameApi, providedIn: "root" });
-BasketballGameApi = __decorate([
-    Injectable({ providedIn: 'root' })
-], BasketballGameApi);
 
 let Feedback = class Feedback {
     static toFront(data) {
@@ -2616,7 +2617,7 @@ Feedback = __decorate([
     })
 ], Feedback);
 
-let FeedbackApi = class FeedbackApi {
+class FeedbackApi {
     constructor(httpClient, configService) {
         this.httpClient = httpClient;
         this.configService = configService;
@@ -2635,17 +2636,17 @@ let FeedbackApi = class FeedbackApi {
                 .toPromise();
         });
     }
-};
+}
+FeedbackApi.ɵprov = i0.ɵɵdefineInjectable({ factory: function FeedbackApi_Factory() { return new FeedbackApi(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(ConfigService)); }, token: FeedbackApi, providedIn: "root" });
+FeedbackApi.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
 FeedbackApi.ctorParameters = () => [
     { type: HttpClient },
     { type: ConfigService }
 ];
-FeedbackApi.ɵprov = ɵɵdefineInjectable({ factory: function FeedbackApi_Factory() { return new FeedbackApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: FeedbackApi, providedIn: "root" });
-FeedbackApi = __decorate([
-    Injectable({ providedIn: 'root' })
-], FeedbackApi);
 
-let FileApi = class FileApi {
+class FileApi {
     constructor(httpClient, configService) {
         this.httpClient = httpClient;
         this.configService = configService;
@@ -2675,15 +2676,15 @@ let FileApi = class FileApi {
                 .toPromise();
         });
     }
-};
+}
+FileApi.ɵprov = i0.ɵɵdefineInjectable({ factory: function FileApi_Factory() { return new FileApi(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(ConfigService)); }, token: FileApi, providedIn: "root" });
+FileApi.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
 FileApi.ctorParameters = () => [
     { type: HttpClient },
     { type: ConfigService }
 ];
-FileApi.ɵprov = ɵɵdefineInjectable({ factory: function FileApi_Factory() { return new FileApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: FileApi, providedIn: "root" });
-FileApi = __decorate([
-    Injectable({ providedIn: 'root' })
-], FileApi);
 
 var HockeyGameLogTypes;
 (function (HockeyGameLogTypes) {
@@ -3070,7 +3071,7 @@ HockeyGameTeamStatistic = __decorate([
     })
 ], HockeyGameTeamStatistic);
 
-let HockeyGameApi = class HockeyGameApi extends GameBaseApi {
+class HockeyGameApi extends GameBaseApi {
     constructor(httpClient, configService) {
         super(httpClient, configService);
         this.httpClient = httpClient;
@@ -3112,15 +3113,15 @@ let HockeyGameApi = class HockeyGameApi extends GameBaseApi {
             }).toPromise();
         });
     }
-};
+}
+HockeyGameApi.ɵprov = i0.ɵɵdefineInjectable({ factory: function HockeyGameApi_Factory() { return new HockeyGameApi(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(ConfigService)); }, token: HockeyGameApi, providedIn: "root" });
+HockeyGameApi.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
 HockeyGameApi.ctorParameters = () => [
     { type: HttpClient },
     { type: ConfigService }
 ];
-HockeyGameApi.ɵprov = ɵɵdefineInjectable({ factory: function HockeyGameApi_Factory() { return new HockeyGameApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: HockeyGameApi, providedIn: "root" });
-HockeyGameApi = __decorate([
-    Injectable({ providedIn: 'root' })
-], HockeyGameApi);
 
 var FootballGameLogTypes;
 (function (FootballGameLogTypes) {
@@ -3503,7 +3504,7 @@ FootballGameTeamStatistic = __decorate([
     })
 ], FootballGameTeamStatistic);
 
-let FootballGameApi = class FootballGameApi extends GameBaseApi {
+class FootballGameApi extends GameBaseApi {
     constructor(httpClient, configService) {
         super(httpClient, configService);
         this.httpClient = httpClient;
@@ -3545,15 +3546,15 @@ let FootballGameApi = class FootballGameApi extends GameBaseApi {
             }).toPromise();
         });
     }
-};
+}
+FootballGameApi.ɵprov = i0.ɵɵdefineInjectable({ factory: function FootballGameApi_Factory() { return new FootballGameApi(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(ConfigService)); }, token: FootballGameApi, providedIn: "root" });
+FootballGameApi.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
 FootballGameApi.ctorParameters = () => [
     { type: HttpClient },
     { type: ConfigService }
 ];
-FootballGameApi.ɵprov = ɵɵdefineInjectable({ factory: function FootballGameApi_Factory() { return new FootballGameApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: FootballGameApi, providedIn: "root" });
-FootballGameApi = __decorate([
-    Injectable({ providedIn: 'root' })
-], FootballGameApi);
 
 var HandballGameLogTypes;
 (function (HandballGameLogTypes) {
@@ -3848,7 +3849,7 @@ HandballGameTeamStatistic = __decorate([
     })
 ], HandballGameTeamStatistic);
 
-let HandballGameApi = class HandballGameApi extends GameBaseApi {
+class HandballGameApi extends GameBaseApi {
     constructor(httpClient, configService) {
         super(httpClient, configService);
         this.httpClient = httpClient;
@@ -3890,15 +3891,15 @@ let HandballGameApi = class HandballGameApi extends GameBaseApi {
             }).toPromise();
         });
     }
-};
+}
+HandballGameApi.ɵprov = i0.ɵɵdefineInjectable({ factory: function HandballGameApi_Factory() { return new HandballGameApi(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(ConfigService)); }, token: HandballGameApi, providedIn: "root" });
+HandballGameApi.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
 HandballGameApi.ctorParameters = () => [
     { type: HttpClient },
     { type: ConfigService }
 ];
-HandballGameApi.ɵprov = ɵɵdefineInjectable({ factory: function HandballGameApi_Factory() { return new HandballGameApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: HandballGameApi, providedIn: "root" });
-HandballGameApi = __decorate([
-    Injectable({ providedIn: 'root' })
-], HandballGameApi);
 
 let TournamentNews = class TournamentNews extends BaseModel {
     static toFront(data) { }
@@ -4319,6 +4320,7 @@ RugbyStatistic = __decorate([
             lineouts_won: 'lineoutsWon',
             lineouts_lost: 'lineoutsLost',
             lineouts_steal: 'lineoutsSteal',
+            lineouts_won_percent: 'lineoutsWonPercent',
             opponent_lineouts_lost: 'opponentLineoutsLost',
             quick_throws: 'quickThrows',
             rucks: 'rucks',
@@ -4347,7 +4349,7 @@ RugbyStatistic = __decorate([
     })
 ], RugbyStatistic);
 
-let TournamentApi = class TournamentApi {
+class TournamentApi {
     constructor(httpClient, configService) {
         this.httpClient = httpClient;
         this.configService = configService;
@@ -4622,15 +4624,15 @@ let TournamentApi = class TournamentApi {
             return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_team_user/${tournamentTeamUserId}/tournaments/`).pipe(map(result => Tournament.toFront(result))).toPromise();
         });
     }
-};
+}
+TournamentApi.ɵprov = i0.ɵɵdefineInjectable({ factory: function TournamentApi_Factory() { return new TournamentApi(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(ConfigService)); }, token: TournamentApi, providedIn: "root" });
+TournamentApi.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
 TournamentApi.ctorParameters = () => [
     { type: HttpClient },
     { type: ConfigService }
 ];
-TournamentApi.ɵprov = ɵɵdefineInjectable({ factory: function TournamentApi_Factory() { return new TournamentApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: TournamentApi, providedIn: "root" });
-TournamentApi = __decorate([
-    Injectable({ providedIn: 'root' })
-], TournamentApi);
 function applyGamesFilters(filters, params) {
     if (filters.tournamentIds) {
         params = params.set('tournament_ids', filters.tournamentIds.join(','));
@@ -4791,7 +4793,7 @@ LeagueDocument = __decorate([
     })
 ], LeagueDocument);
 
-let LeagueApi = class LeagueApi {
+class LeagueApi {
     constructor(httpClient, configService) {
         this.httpClient = httpClient;
         this.configService = configService;
@@ -4898,17 +4900,17 @@ let LeagueApi = class LeagueApi {
             return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/league/${leagueId}/documents/`).pipe(map(result => LeagueDocument.toFront(result))).toPromise();
         });
     }
-};
+}
+LeagueApi.ɵprov = i0.ɵɵdefineInjectable({ factory: function LeagueApi_Factory() { return new LeagueApi(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(ConfigService)); }, token: LeagueApi, providedIn: "root" });
+LeagueApi.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
 LeagueApi.ctorParameters = () => [
     { type: HttpClient },
     { type: ConfigService }
 ];
-LeagueApi.ɵprov = ɵɵdefineInjectable({ factory: function LeagueApi_Factory() { return new LeagueApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: LeagueApi, providedIn: "root" });
-LeagueApi = __decorate([
-    Injectable({ providedIn: 'root' })
-], LeagueApi);
 
-let LeagueNewsApi = class LeagueNewsApi {
+class LeagueNewsApi {
     constructor(httpClient, configService) {
         this.httpClient = httpClient;
         this.configService = configService;
@@ -4957,17 +4959,17 @@ let LeagueNewsApi = class LeagueNewsApi {
                 .toPromise();
         });
     }
-};
+}
+LeagueNewsApi.ɵprov = i0.ɵɵdefineInjectable({ factory: function LeagueNewsApi_Factory() { return new LeagueNewsApi(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(ConfigService)); }, token: LeagueNewsApi, providedIn: "root" });
+LeagueNewsApi.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
 LeagueNewsApi.ctorParameters = () => [
     { type: HttpClient },
     { type: ConfigService }
 ];
-LeagueNewsApi.ɵprov = ɵɵdefineInjectable({ factory: function LeagueNewsApi_Factory() { return new LeagueNewsApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: LeagueNewsApi, providedIn: "root" });
-LeagueNewsApi = __decorate([
-    Injectable({ providedIn: 'root' })
-], LeagueNewsApi);
 
-let LeaguePlayerApi = class LeaguePlayerApi {
+class LeaguePlayerApi {
     constructor(httpClient, configService) {
         this.httpClient = httpClient;
         this.configService = configService;
@@ -4982,17 +4984,17 @@ let LeaguePlayerApi = class LeaguePlayerApi {
         }
         return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/league_player/${leaguePlayerId}/tournament_users/`, { params }).pipe(map(item => TournamentTeamUser.toFront(item))).toPromise();
     }
-};
+}
+LeaguePlayerApi.ɵprov = i0.ɵɵdefineInjectable({ factory: function LeaguePlayerApi_Factory() { return new LeaguePlayerApi(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(ConfigService)); }, token: LeaguePlayerApi, providedIn: "root" });
+LeaguePlayerApi.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
 LeaguePlayerApi.ctorParameters = () => [
     { type: HttpClient },
     { type: ConfigService }
 ];
-LeaguePlayerApi.ɵprov = ɵɵdefineInjectable({ factory: function LeaguePlayerApi_Factory() { return new LeaguePlayerApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: LeaguePlayerApi, providedIn: "root" });
-LeaguePlayerApi = __decorate([
-    Injectable({ providedIn: 'root' })
-], LeaguePlayerApi);
 
-let MediaApi = class MediaApi {
+class MediaApi {
     constructor(httpClient, configService) {
         this.httpClient = httpClient;
         this.configService = configService;
@@ -5068,15 +5070,15 @@ let MediaApi = class MediaApi {
                 .toPromise();
         });
     }
-};
+}
+MediaApi.ɵprov = i0.ɵɵdefineInjectable({ factory: function MediaApi_Factory() { return new MediaApi(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(ConfigService)); }, token: MediaApi, providedIn: "root" });
+MediaApi.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
 MediaApi.ctorParameters = () => [
     { type: HttpClient },
     { type: ConfigService }
 ];
-MediaApi.ɵprov = ɵɵdefineInjectable({ factory: function MediaApi_Factory() { return new MediaApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: MediaApi, providedIn: "root" });
-MediaApi = __decorate([
-    Injectable({ providedIn: 'root' })
-], MediaApi);
 function applyGameMediaFilters(filters, params) {
     if (filters) {
         params = applyGamesFilters(filters, params);
@@ -5590,7 +5592,7 @@ NotificationSettings = __decorate([
     })
 ], NotificationSettings);
 
-let NotificationBaseApi = class NotificationBaseApi {
+class NotificationBaseApi {
     constructor(httpClient, configService) {
         this.httpClient = httpClient;
         this.configService = configService;
@@ -5652,39 +5654,39 @@ let NotificationBaseApi = class NotificationBaseApi {
                 .toPromise();
         });
     }
-};
+}
+NotificationBaseApi.ɵprov = i0.ɵɵdefineInjectable({ factory: function NotificationBaseApi_Factory() { return new NotificationBaseApi(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(ConfigService)); }, token: NotificationBaseApi, providedIn: "root" });
+NotificationBaseApi.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
 NotificationBaseApi.ctorParameters = () => [
     { type: HttpClient },
     { type: ConfigService }
 ];
-NotificationBaseApi.ɵprov = ɵɵdefineInjectable({ factory: function NotificationBaseApi_Factory() { return new NotificationBaseApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: NotificationBaseApi, providedIn: "root" });
-NotificationBaseApi = __decorate([
-    Injectable({ providedIn: 'root' })
-], NotificationBaseApi);
 
-let NotificationApi = class NotificationApi extends NotificationBaseApi {
+class NotificationApi extends NotificationBaseApi {
     constructor() {
         super(...arguments);
         this.apiUrl = '/api/v1';
     }
-};
-NotificationApi.ɵprov = ɵɵdefineInjectable({ factory: function NotificationApi_Factory() { return new NotificationApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: NotificationApi, providedIn: "root" });
-NotificationApi = __decorate([
-    Injectable({ providedIn: 'root' })
-], NotificationApi);
+}
+NotificationApi.ɵprov = i0.ɵɵdefineInjectable({ factory: function NotificationApi_Factory() { return new NotificationApi(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(ConfigService)); }, token: NotificationApi, providedIn: "root" });
+NotificationApi.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
 
-let OrgNotificationApi = class OrgNotificationApi extends NotificationBaseApi {
+class OrgNotificationApi extends NotificationBaseApi {
     constructor() {
         super(...arguments);
         this.apiUrl = '/org/api/v1';
     }
-};
-OrgNotificationApi.ɵprov = ɵɵdefineInjectable({ factory: function OrgNotificationApi_Factory() { return new OrgNotificationApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: OrgNotificationApi, providedIn: "root" });
-OrgNotificationApi = __decorate([
-    Injectable({ providedIn: 'root' })
-], OrgNotificationApi);
+}
+OrgNotificationApi.ɵprov = i0.ɵɵdefineInjectable({ factory: function OrgNotificationApi_Factory() { return new OrgNotificationApi(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(ConfigService)); }, token: OrgNotificationApi, providedIn: "root" });
+OrgNotificationApi.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
 
-let ReferenceApi = class ReferenceApi {
+class ReferenceApi {
     constructor(httpClient, configService) {
         this.httpClient = httpClient;
         this.configService = configService;
@@ -5703,15 +5705,15 @@ let ReferenceApi = class ReferenceApi {
                 .pipe(map(data => Sport.toFront(data))).toPromise();
         });
     }
-};
+}
+ReferenceApi.ɵprov = i0.ɵɵdefineInjectable({ factory: function ReferenceApi_Factory() { return new ReferenceApi(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(ConfigService)); }, token: ReferenceApi, providedIn: "root" });
+ReferenceApi.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
 ReferenceApi.ctorParameters = () => [
     { type: HttpClient },
     { type: ConfigService }
 ];
-ReferenceApi.ɵprov = ɵɵdefineInjectable({ factory: function ReferenceApi_Factory() { return new ReferenceApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: ReferenceApi, providedIn: "root" });
-ReferenceApi = __decorate([
-    Injectable({ providedIn: 'root' })
-], ReferenceApi);
 
 let RugbyGameTeamStatistic = class RugbyGameTeamStatistic extends BaseModel {
     static toFront(data) { }
@@ -5866,7 +5868,7 @@ const RUGBY_GAME_LOG_TYPE_POINTS = {
     [RugbyGameLogTypes.conversion_goal]: 2,
     [RugbyGameLogTypes.penalty_goal]: 3,
     [RugbyGameLogTypes.drop_goal]: 3,
-    [RugbyGameLogTypes.end_game_penalty_goal]: 1,
+    [RugbyGameLogTypes.end_game_penalty_goal]: 1, // Не влияет на общий счет
 };
 const RUGBY_TEAM_LOG_TYPES = [
     RugbyGameLogTypes.timeout, RugbyGameLogTypes.scrum_won, RugbyGameLogTypes.scrum_lost, RugbyGameLogTypes.scrum_won_free,
@@ -5951,7 +5953,7 @@ RugbyGameLog = __decorate([
     })
 ], RugbyGameLog);
 
-let RugbyGameApi = class RugbyGameApi extends GameBaseApi {
+class RugbyGameApi extends GameBaseApi {
     constructor(httpClient, configService) {
         super(httpClient, configService);
         this.httpClient = httpClient;
@@ -5990,15 +5992,15 @@ let RugbyGameApi = class RugbyGameApi extends GameBaseApi {
             }).toPromise();
         });
     }
-};
+}
+RugbyGameApi.ɵprov = i0.ɵɵdefineInjectable({ factory: function RugbyGameApi_Factory() { return new RugbyGameApi(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(ConfigService)); }, token: RugbyGameApi, providedIn: "root" });
+RugbyGameApi.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
 RugbyGameApi.ctorParameters = () => [
     { type: HttpClient },
     { type: ConfigService }
 ];
-RugbyGameApi.ɵprov = ɵɵdefineInjectable({ factory: function RugbyGameApi_Factory() { return new RugbyGameApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: RugbyGameApi, providedIn: "root" });
-RugbyGameApi = __decorate([
-    Injectable({ providedIn: 'root' })
-], RugbyGameApi);
 
 let TeamInviteExternal = class TeamInviteExternal extends BaseModel {
     static toFront(data) { }
@@ -6098,7 +6100,7 @@ TeamAccess = __decorate([
     })
 ], TeamAccess);
 
-let TeamApi = class TeamApi {
+class TeamApi {
     constructor(httpClient, configService) {
         this.httpClient = httpClient;
         this.configService = configService;
@@ -6458,17 +6460,17 @@ let TeamApi = class TeamApi {
                 .toPromise();
         });
     }
-};
+}
+TeamApi.ɵprov = i0.ɵɵdefineInjectable({ factory: function TeamApi_Factory() { return new TeamApi(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(ConfigService)); }, token: TeamApi, providedIn: "root" });
+TeamApi.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
 TeamApi.ctorParameters = () => [
     { type: HttpClient },
     { type: ConfigService }
 ];
-TeamApi.ɵprov = ɵɵdefineInjectable({ factory: function TeamApi_Factory() { return new TeamApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: TeamApi, providedIn: "root" });
-TeamApi = __decorate([
-    Injectable({ providedIn: 'root' })
-], TeamApi);
 
-let TeamEventApi = class TeamEventApi {
+class TeamEventApi {
     constructor(httpClient, configService) {
         this.httpClient = httpClient;
         this.configService = configService;
@@ -6528,15 +6530,15 @@ let TeamEventApi = class TeamEventApi {
                 .toPromise();
         });
     }
-};
+}
+TeamEventApi.ɵprov = i0.ɵɵdefineInjectable({ factory: function TeamEventApi_Factory() { return new TeamEventApi(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(ConfigService)); }, token: TeamEventApi, providedIn: "root" });
+TeamEventApi.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
 TeamEventApi.ctorParameters = () => [
     { type: HttpClient },
     { type: ConfigService }
 ];
-TeamEventApi.ɵprov = ɵɵdefineInjectable({ factory: function TeamEventApi_Factory() { return new TeamEventApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: TeamEventApi, providedIn: "root" });
-TeamEventApi = __decorate([
-    Injectable({ providedIn: 'root' })
-], TeamEventApi);
 
 let TournamentJoinData = class TournamentJoinData extends BaseModel {
     get usersCount() {
@@ -6588,7 +6590,7 @@ TournamentJoinTeam = __decorate([
     })
 ], TournamentJoinTeam);
 
-let TournamentJoinApi = class TournamentJoinApi {
+class TournamentJoinApi {
     constructor(httpClient, configService) {
         this.httpClient = httpClient;
         this.configService = configService;
@@ -6616,17 +6618,17 @@ let TournamentJoinApi = class TournamentJoinApi {
                 .toPromise();
         });
     }
-};
+}
+TournamentJoinApi.ɵprov = i0.ɵɵdefineInjectable({ factory: function TournamentJoinApi_Factory() { return new TournamentJoinApi(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(ConfigService)); }, token: TournamentJoinApi, providedIn: "root" });
+TournamentJoinApi.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
 TournamentJoinApi.ctorParameters = () => [
     { type: HttpClient },
     { type: ConfigService }
 ];
-TournamentJoinApi.ɵprov = ɵɵdefineInjectable({ factory: function TournamentJoinApi_Factory() { return new TournamentJoinApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: TournamentJoinApi, providedIn: "root" });
-TournamentJoinApi = __decorate([
-    Injectable({ providedIn: 'root' })
-], TournamentJoinApi);
 
-let TournamentSeasonApi = class TournamentSeasonApi {
+class TournamentSeasonApi {
     constructor(httpClient, configService) {
         this.httpClient = httpClient;
         this.configService = configService;
@@ -6711,17 +6713,17 @@ let TournamentSeasonApi = class TournamentSeasonApi {
                 .toPromise();
         });
     }
-};
+}
+TournamentSeasonApi.ɵprov = i0.ɵɵdefineInjectable({ factory: function TournamentSeasonApi_Factory() { return new TournamentSeasonApi(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(ConfigService)); }, token: TournamentSeasonApi, providedIn: "root" });
+TournamentSeasonApi.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
 TournamentSeasonApi.ctorParameters = () => [
     { type: HttpClient },
     { type: ConfigService }
 ];
-TournamentSeasonApi.ɵprov = ɵɵdefineInjectable({ factory: function TournamentSeasonApi_Factory() { return new TournamentSeasonApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: TournamentSeasonApi, providedIn: "root" });
-TournamentSeasonApi = __decorate([
-    Injectable({ providedIn: 'root' })
-], TournamentSeasonApi);
 
-let TournamentStageApi = class TournamentStageApi {
+class TournamentStageApi {
     constructor(httpClient, configService) {
         this.httpClient = httpClient;
         this.configService = configService;
@@ -6754,15 +6756,15 @@ let TournamentStageApi = class TournamentStageApi {
                 .toPromise();
         });
     }
-};
+}
+TournamentStageApi.ɵprov = i0.ɵɵdefineInjectable({ factory: function TournamentStageApi_Factory() { return new TournamentStageApi(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(ConfigService)); }, token: TournamentStageApi, providedIn: "root" });
+TournamentStageApi.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
 TournamentStageApi.ctorParameters = () => [
     { type: HttpClient },
     { type: ConfigService }
 ];
-TournamentStageApi.ɵprov = ɵɵdefineInjectable({ factory: function TournamentStageApi_Factory() { return new TournamentStageApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: TournamentStageApi, providedIn: "root" });
-TournamentStageApi = __decorate([
-    Injectable({ providedIn: 'root' })
-], TournamentStageApi);
 
 let UserAccess = class UserAccess extends BaseModel {
     static toFront(data) { }
@@ -6821,7 +6823,7 @@ UserPermission = __decorate([
     })
 ], UserPermission);
 
-let UserApi = class UserApi {
+class UserApi {
     constructor(httpClient, configService) {
         this.httpClient = httpClient;
         this.configService = configService;
@@ -7072,15 +7074,15 @@ let UserApi = class UserApi {
                 .toPromise();
         });
     }
-};
+}
+UserApi.ɵprov = i0.ɵɵdefineInjectable({ factory: function UserApi_Factory() { return new UserApi(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(ConfigService)); }, token: UserApi, providedIn: "root" });
+UserApi.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
 UserApi.ctorParameters = () => [
     { type: HttpClient },
     { type: ConfigService }
 ];
-UserApi.ɵprov = ɵɵdefineInjectable({ factory: function UserApi_Factory() { return new UserApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: UserApi, providedIn: "root" });
-UserApi = __decorate([
-    Injectable({ providedIn: 'root' })
-], UserApi);
 
 let VolleyballGameTeamStatistic = class VolleyballGameTeamStatistic extends BaseModel {
     static toFront(data) { }
@@ -7292,7 +7294,7 @@ VolleyballGameLog = __decorate([
     })
 ], VolleyballGameLog);
 
-let VolleyballGameApi = class VolleyballGameApi extends GameBaseApi {
+class VolleyballGameApi extends GameBaseApi {
     constructor(httpClient, configService) {
         super(httpClient, configService);
         this.httpClient = httpClient;
@@ -7334,17 +7336,17 @@ let VolleyballGameApi = class VolleyballGameApi extends GameBaseApi {
             }).toPromise();
         });
     }
-};
+}
+VolleyballGameApi.ɵprov = i0.ɵɵdefineInjectable({ factory: function VolleyballGameApi_Factory() { return new VolleyballGameApi(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(ConfigService)); }, token: VolleyballGameApi, providedIn: "root" });
+VolleyballGameApi.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
 VolleyballGameApi.ctorParameters = () => [
     { type: HttpClient },
     { type: ConfigService }
 ];
-VolleyballGameApi.ɵprov = ɵɵdefineInjectable({ factory: function VolleyballGameApi_Factory() { return new VolleyballGameApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: VolleyballGameApi, providedIn: "root" });
-VolleyballGameApi = __decorate([
-    Injectable({ providedIn: 'root' })
-], VolleyballGameApi);
 
-let PublicTeamApi = class PublicTeamApi {
+class PublicTeamApi {
     constructor(httpClient, configService) {
         this.httpClient = httpClient;
         this.configService = configService;
@@ -7356,17 +7358,17 @@ let PublicTeamApi = class PublicTeamApi {
         const params = new HttpParams().set('league_id', leagueId.toString());
         return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/public_team/${teamId}/tournament_teams/`, { params }).pipe(map(result => TournamentTeam.toFront(result))).toPromise();
     }
-};
+}
+PublicTeamApi.ɵprov = i0.ɵɵdefineInjectable({ factory: function PublicTeamApi_Factory() { return new PublicTeamApi(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(ConfigService)); }, token: PublicTeamApi, providedIn: "root" });
+PublicTeamApi.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
 PublicTeamApi.ctorParameters = () => [
     { type: HttpClient },
     { type: ConfigService }
 ];
-PublicTeamApi.ɵprov = ɵɵdefineInjectable({ factory: function PublicTeamApi_Factory() { return new PublicTeamApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: PublicTeamApi, providedIn: "root" });
-PublicTeamApi = __decorate([
-    Injectable({ providedIn: 'root' })
-], PublicTeamApi);
 
-let PublicUserApi = class PublicUserApi {
+class PublicUserApi {
     constructor(httpClient, configService) {
         this.httpClient = httpClient;
         this.configService = configService;
@@ -7386,15 +7388,15 @@ let PublicUserApi = class PublicUserApi {
         const params = new HttpParams().set('league_id', leagueId.toString());
         return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/public_user/${userId}/league_player/`, { params }).pipe(map(result => LeaguePlayer.toFront(result))).toPromise();
     }
-};
+}
+PublicUserApi.ɵprov = i0.ɵɵdefineInjectable({ factory: function PublicUserApi_Factory() { return new PublicUserApi(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(ConfigService)); }, token: PublicUserApi, providedIn: "root" });
+PublicUserApi.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
 PublicUserApi.ctorParameters = () => [
     { type: HttpClient },
     { type: ConfigService }
 ];
-PublicUserApi.ɵprov = ɵɵdefineInjectable({ factory: function PublicUserApi_Factory() { return new PublicUserApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: PublicUserApi, providedIn: "root" });
-PublicUserApi = __decorate([
-    Injectable({ providedIn: 'root' })
-], PublicUserApi);
 
 const BasketballGameLogTypeLocalization = {
     [BasketballGameLogTypes.enter_game]: 'Выход на площадку',
@@ -7703,7 +7705,7 @@ LeaguePlaylist = __decorate([
     })
 ], LeaguePlaylist);
 
-let CentrifugoService = class CentrifugoService {
+class CentrifugoService {
     constructor(httpClient, configService) {
         this.httpClient = httpClient;
         this.configService = configService;
@@ -7795,15 +7797,15 @@ let CentrifugoService = class CentrifugoService {
         }
         this.channels$[channel].next(response.data);
     }
-};
+}
+CentrifugoService.ɵprov = i0.ɵɵdefineInjectable({ factory: function CentrifugoService_Factory() { return new CentrifugoService(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(ConfigService)); }, token: CentrifugoService, providedIn: "root" });
+CentrifugoService.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
 CentrifugoService.ctorParameters = () => [
     { type: HttpClient },
     { type: ConfigService }
 ];
-CentrifugoService.ɵprov = ɵɵdefineInjectable({ factory: function CentrifugoService_Factory() { return new CentrifugoService(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: CentrifugoService, providedIn: "root" });
-CentrifugoService = __decorate([
-    Injectable({ providedIn: 'root' })
-], CentrifugoService);
 
 class StorageEngineField {
     constructor(defaultValue, modelClass) {
@@ -8033,7 +8035,7 @@ function fileSizeValidator(maxFileSize) {
     };
 }
 
-let HttpCookieInterceptor = class HttpCookieInterceptor {
+class HttpCookieInterceptor {
     constructor(injector, configService, platformId) {
         this.injector = injector;
         this.configService = configService;
@@ -8056,16 +8058,15 @@ let HttpCookieInterceptor = class HttpCookieInterceptor {
         }
         return next.handle(req);
     }
-};
+}
+HttpCookieInterceptor.decorators = [
+    { type: Injectable }
+];
 HttpCookieInterceptor.ctorParameters = () => [
     { type: Injector },
     { type: ConfigService },
     { type: String, decorators: [{ type: Inject, args: [PLATFORM_ID,] }] }
 ];
-HttpCookieInterceptor = __decorate([
-    Injectable(),
-    __param(2, Inject(PLATFORM_ID))
-], HttpCookieInterceptor);
 
 /**
  * Generated bundle index. Do not edit.