@mtgame/core 0.0.56 → 0.0.57

package/bundles/mtgame-core.umd.js

@@ -1386,6 +1386,7 @@
                     team_second: 'teamSecond',
                     team_third: 'teamThird',
                     season: 'season',
+                    season_id: 'seasonId',
                 },
                 relation: {
                     logo: File,
@@ -3709,178 +3710,936 @@
         return FootballGameApi;
     }(GameBaseApi));
 
-
-    (function (LeagueNewsType) {
-        LeagueNewsType[LeagueNewsType["text"] = 1] = "text";
-        LeagueNewsType[LeagueNewsType["video"] = 2] = "video";
-    })(exports.LeagueNewsType || (exports.LeagueNewsType = {}));
-    var LeagueNews = /** @class */ (function (_super) {
-        __extends(LeagueNews, _super);
-        function LeagueNews() {
+    var TournamentNews = /** @class */ (function (_super) {
+        __extends(TournamentNews, _super);
+        function TournamentNews() {
             return _super !== null && _super.apply(this, arguments) || this;
         }
-        LeagueNews.toFront = function (data) {
-            return undefined;
-        };
-        LeagueNews.toBack = function (data) { };
+        TournamentNews.toFront = function (data) { };
+        TournamentNews.toBack = function (data) { };
         __decorate([
             ToFrontHook
-        ], LeagueNews, "toFront", null);
+        ], TournamentNews, "toFront", null);
         __decorate([
             ToBackHook
-        ], LeagueNews, "toBack", null);
-        LeagueNews = __decorate([
+        ], TournamentNews, "toBack", null);
+        TournamentNews = __decorate([
             ModelInstance({
                 mappingFields: {
                     id: 'id',
                     title: 'title',
-                    datetime: 'datetime',
-                    preview_text: 'previewText',
-                    detail_text: 'detailText',
                     picture: 'picture',
-                    cover: 'cover',
-                    mobile_picture: 'mobilePicture',
-                    is_main: 'isMain',
-                    tournaments: 'tournaments',
-                    type: 'type',
-                    video_link: 'videoLink',
-                    tag: 'tag',
+                    text: 'text',
+                    author: 'author',
+                    created_at: 'createdAt',
                 },
                 relation: {
-                    datetime: DateTimeField,
                     picture: File,
-                    cover: File,
-                    mobilePicture: File,
-                    tournaments: listField(Tournament),
-                    type: enumField(exports.LeagueNewsType),
+                    author: User,
+                    createdAt: DateTimeField,
                 }
             })
-        ], LeagueNews);
-        return LeagueNews;
+        ], TournamentNews);
+        return TournamentNews;
     }(BaseModel));
 
-
-    (function (TournamentEventTypes) {
-        TournamentEventTypes[TournamentEventTypes["game_closed"] = 1] = "game_closed";
-        TournamentEventTypes[TournamentEventTypes["media_added"] = 2] = "media_added";
-        TournamentEventTypes[TournamentEventTypes["news"] = 3] = "news";
-    })(exports.TournamentEventTypes || (exports.TournamentEventTypes = {}));
-    var TournamentEvent = /** @class */ (function (_super) {
-        __extends(TournamentEvent, _super);
-        function TournamentEvent() {
+    var GameTimelineStageItem = /** @class */ (function () {
+        function GameTimelineStageItem() {
+        }
+        GameTimelineStageItem.toFront = function (data) { };
+        GameTimelineStageItem.toBack = function (data) { };
+        __decorate([
+            ToFrontHook
+        ], GameTimelineStageItem, "toFront", null);
+        __decorate([
+            ToBackHook
+        ], GameTimelineStageItem, "toBack", null);
+        GameTimelineStageItem = __decorate([
+            ModelInstance({
+                mappingFields: {
+                    stage_id: 'stageId',
+                    tours_count: 'toursCount',
+                    playoff_stages_count: 'playoffStagesCount',
+                }
+            })
+        ], GameTimelineStageItem);
+        return GameTimelineStageItem;
+    }());
+    var GameTimelineStages = /** @class */ (function (_super) {
+        __extends(GameTimelineStages, _super);
+        function GameTimelineStages() {
             return _super !== null && _super.apply(this, arguments) || this;
         }
-        TournamentEvent.toFront = function (data) { };
-        TournamentEvent.toBack = function (data) { };
+        GameTimelineStages.toFront = function (data) { };
+        GameTimelineStages.toBack = function (data) { };
         __decorate([
             ToFrontHook
-        ], TournamentEvent, "toFront", null);
+        ], GameTimelineStages, "toFront", null);
         __decorate([
             ToBackHook
-        ], TournamentEvent, "toBack", null);
-        TournamentEvent = __decorate([
+        ], GameTimelineStages, "toBack", null);
+        GameTimelineStages = __decorate([
             ModelInstance({
                 mappingFields: {
-                    id: 'id',
-                    game: 'game',
-                    news: 'news',
-                    league: 'league',
-                    tournaments: 'tournaments',
-                    event: 'event',
-                    datetime: 'datetime'
+                    tours_count: 'toursCount',
+                    playoff_stages_count: 'playoffStagesCount',
+                    current_tour: 'currentTour',
+                    current_playoff_stage: 'currentPlayoffStage',
+                    stages: 'stages',
+                    tournament_stage_id: 'tournamentStageId',
                 },
                 relation: {
-                    game: Game,
-                    news: LeagueNews,
-                    league: League,
-                    tournaments: listField(Tournament),
-                    datetime: DateField,
-                    event: enumField(exports.TournamentEventTypes)
+                    stages: listField(GameTimelineStageItem)
                 }
             })
-        ], TournamentEvent);
-        return TournamentEvent;
+        ], GameTimelineStages);
+        return GameTimelineStages;
     }(BaseModel));
 
-    var LeaguePartner = /** @class */ (function (_super) {
-        __extends(LeaguePartner, _super);
-        function LeaguePartner() {
+
+    (function (TournamentStageStatuses) {
+        TournamentStageStatuses[TournamentStageStatuses["open"] = 0] = "open";
+        TournamentStageStatuses[TournamentStageStatuses["in_progress"] = 1] = "in_progress";
+        TournamentStageStatuses[TournamentStageStatuses["closed"] = 2] = "closed";
+    })(exports.TournamentStageStatuses || (exports.TournamentStageStatuses = {}));
+    var TournamentStage = /** @class */ (function (_super) {
+        __extends(TournamentStage, _super);
+        function TournamentStage() {
             return _super !== null && _super.apply(this, arguments) || this;
         }
-        LeaguePartner.toFront = function (data) { };
-        LeaguePartner.toBack = function (data) { };
+        TournamentStage.toFront = function (data) { };
+        TournamentStage.toBack = function (data) { };
         __decorate([
             ToFrontHook
-        ], LeaguePartner, "toFront", null);
+        ], TournamentStage, "toFront", null);
         __decorate([
             ToBackHook
-        ], LeaguePartner, "toBack", null);
-        LeaguePartner = __decorate([
+        ], TournamentStage, "toBack", null);
+        TournamentStage = __decorate([
             ModelInstance({
                 mappingFields: {
                     id: 'id',
-                    title: 'title',
-                    picture: 'picture',
-                    link: 'link',
-                    sort: 'sort',
+                    name: 'name',
+                    date: 'date',
+                    tournament_id: 'tournamentId',
+                    status: 'status',
                 },
                 relation: {
-                    picture: File
+                    date: DateField,
+                    status: enumField(exports.TournamentStageStatuses)
                 }
             })
-        ], LeaguePartner);
-        return LeaguePartner;
+        ], TournamentStage);
+        return TournamentStage;
     }(BaseModel));
 
+    function generateArray(length) {
+        if (length <= 0) {
+            return [];
+        }
+        return Array.apply(null, Array(length)).map(function (_, i) { return i + 1; });
+    }
+    function getArrayChunks(array, length) {
+        var chunks = [];
+        var chunkLength = Math.ceil(array.length / length);
+        if (chunkLength === 0) {
+            return [array];
+        }
+        for (var i = 0; i < chunkLength; i++) {
+            chunks.push(array.slice(i * length, (i + 1) * length));
+        }
+        return chunks;
+    }
+
 
-    (function (BannerLocation) {
-        BannerLocation["slider"] = "slider";
-        BannerLocation["central"] = "central";
-        BannerLocation["media"] = "media";
-    })(exports.BannerLocation || (exports.BannerLocation = {}));
-    var LeagueBanner = /** @class */ (function (_super) {
-        __extends(LeagueBanner, _super);
-        function LeagueBanner() {
+    (function (PlayoffTypes) {
+        PlayoffTypes["double_elimination"] = "double_elimination";
+        PlayoffTypes["elimination"] = "elimination";
+    })(exports.PlayoffTypes || (exports.PlayoffTypes = {}));
+    var PlayoffSettings = /** @class */ (function (_super) {
+        __extends(PlayoffSettings, _super);
+        function PlayoffSettings() {
             return _super !== null && _super.apply(this, arguments) || this;
         }
-        LeagueBanner.toFront = function (data) {
-        };
-        LeagueBanner.toBack = function (data) {
-        };
+        PlayoffSettings.toFront = function (data) { };
+        PlayoffSettings.toBack = function (data) { };
         __decorate([
             ToFrontHook
-        ], LeagueBanner, "toFront", null);
+        ], PlayoffSettings, "toFront", null);
         __decorate([
             ToBackHook
-        ], LeagueBanner, "toBack", null);
-        LeagueBanner = __decorate([
+        ], PlayoffSettings, "toBack", null);
+        PlayoffSettings = __decorate([
             ModelInstance({
                 mappingFields: {
-                    id: 'id',
-                    title: 'title',
-                    picture: 'picture',
-                    link: 'link',
-                    sort: 'sort',
-                    location: 'location',
+                    rounds: 'rounds',
+                    final_rounds: 'finalRounds',
+                    third_place_rounds: 'thirdPlaceRounds',
+                    teams_count: 'teamsCount',
+                    type: 'type',
                 },
                 relation: {
-                    picture: File,
-                    location: enumField(exports.BannerLocation),
+                    type: enumField(exports.PlayoffTypes)
                 }
             })
-        ], LeagueBanner);
-        return LeagueBanner;
+        ], PlayoffSettings);
+        return PlayoffSettings;
     }(BaseModel));
-
-    var LeagueApi = /** @class */ (function () {
-        function LeagueApi(httpClient, configService) {
-            this.httpClient = httpClient;
-            this.configService = configService;
+    var Playoff = /** @class */ (function (_super) {
+        __extends(Playoff, _super);
+        function Playoff() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this.stages = [];
+            return _this;
         }
-        LeagueApi.prototype.getByAlias = function (alias) {
-            return __awaiter(this, void 0, void 0, function () {
-                return __generator(this, function (_a) {
-                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/league/" + alias + "/").pipe(operators.map(function (result) { return League.toFront(result); })).toPromise()];
+        Playoff.toFront = function (data) { };
+        Playoff.toBack = function (data) { };
+        Object.defineProperty(Playoff.prototype, "stagesCount", {
+            get: function () {
+                return Math.log(this.settings.teamsCount) / Math.log(2);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Playoff.prototype.getPlayoffStages = function () {
+            var _this = this;
+            if (this.stages.length === 0 && this.settings.teamsCount) {
+                var stagesCount = Math.log(this.settings.teamsCount) / Math.log(2);
+                this.stages = generateArray(stagesCount).map(function (stage) {
+                    var playoffStage = _this.settings.teamsCount / Math.pow(2, stage);
+                    var title = '';
+                    if (playoffStage === 1) {
+                        title = 'Финал';
+                    }
+                    else {
+                        title = "1 / " + playoffStage;
+                    }
+                    return {
+                        value: stage,
+                        title: title
+                    };
+                });
+            }
+            return this.stages;
+        };
+        __decorate([
+            ToFrontHook
+        ], Playoff, "toFront", null);
+        __decorate([
+            ToBackHook
+        ], Playoff, "toBack", null);
+        Playoff = __decorate([
+            ModelInstance({
+                mappingFields: {
+                    id: 'id',
+                    name: 'name',
+                    settings: 'settings',
+                    tournament_id: 'tournamentId',
+                    tournament_stage_id: 'tournamentStageId',
+                    is_official: 'isOfficial'
+                },
+                relation: {
+                    settings: PlayoffSettings
+                }
+            })
+        ], Playoff);
+        return Playoff;
+    }(BaseModel));
+
+    var VolleyballStatistic = /** @class */ (function (_super) {
+        __extends(VolleyballStatistic, _super);
+        function VolleyballStatistic() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        VolleyballStatistic.toFront = function (data) { };
+        VolleyballStatistic.toBack = function (data) { };
+        __decorate([
+            ToFrontHook
+        ], VolleyballStatistic, "toFront", null);
+        __decorate([
+            ToBackHook
+        ], VolleyballStatistic, "toBack", null);
+        VolleyballStatistic = __decorate([
+            ModelInstance({
+                mappingFields: {
+                    team: 'team',
+                    team_user: 'teamUser',
+                    tournament_team_user: 'tournamentTeamUser',
+                    tournament_team: 'tournamentTeam',
+                    user: 'user',
+                    month: 'month',
+                    win_lose: 'winLose',
+                    games_count: 'gamesCount',
+                    won_games_count: 'wonGamesCount',
+                    serve_hits: 'serveHits',
+                    serve_faults: 'serveFaults',
+                    serve_aces: 'serveAces',
+                    serve_percent: 'servePercent',
+                    ace_percent: 'acePercent',
+                    stuff_blocks: 'stuffBlocks',
+                    block_faults: 'blockFaults',
+                    block_rebounds: 'blockRebounds',
+                    block_percent: 'blockPercent',
+                    attack_spikes: 'attackSpikes',
+                    attack_faults: 'attackFaults',
+                    attack_shots: 'attackShots',
+                    attack_percent: 'attackPercent',
+                    receives: 'receives',
+                    receive_faults: 'receiveFaults',
+                    excellent_receives: 'excellentReceives',
+                    receive_percent: 'receivePercent',
+                    serve_receives: 'serveReceives',
+                    serve_receive_faults: 'serveReceiveFaults',
+                    excellent_serve_receives: 'excellentServeReceives',
+                    serve_receive_percent: 'serveReceivePercent',
+                    points: 'points',
+                    faults: 'faults',
+                    newbie: 'newbie',
+                },
+                relation: {
+                    team: Team,
+                    teamUser: TeamUser,
+                    tournamentTeamUser: TournamentTeamUser,
+                    tournamentTeam: TournamentTeam,
+                    user: User,
+                    month: DateField,
+                }
+            })
+        ], VolleyballStatistic);
+        return VolleyballStatistic;
+    }(BaseStatistic));
+
+    var TournamentStageTeam = /** @class */ (function (_super) {
+        __extends(TournamentStageTeam, _super);
+        function TournamentStageTeam() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        Object.defineProperty(TournamentStageTeam.prototype, "gamesWonPercent", {
+            get: function () {
+                if (!this.gamesCount) {
+                    return 0;
+                }
+                return Math.floor(1000 * this.wonGamesCount / this.gamesCount) / 10;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        TournamentStageTeam.toFront = function (data) { };
+        TournamentStageTeam.toBack = function (data) { };
+        __decorate([
+            ToFrontHook
+        ], TournamentStageTeam, "toFront", null);
+        __decorate([
+            ToBackHook
+        ], TournamentStageTeam, "toBack", null);
+        TournamentStageTeam = __decorate([
+            ModelInstance({
+                mappingFields: {
+                    id: 'id',
+                    tournament_team: 'tournamentTeam',
+                    group: 'group',
+                    tournament_stage_id: 'tournamentStageId',
+                    games_count: 'gamesCount',
+                    won_games_count: 'wonGamesCount',
+                    score_sum: 'scoreSum',
+                    missed_sum: 'missedSum',
+                    last_games_count: 'lastGamesCount',
+                    last_games_won: 'lastGamesWon',
+                    points: 'points',
+                    final_standing: 'finalStanding',
+                    received_points: 'receivedPoints',
+                },
+                relation: {
+                    tournamentTeam: TournamentTeam,
+                    group: TournamentGroup
+                }
+            })
+        ], TournamentStageTeam);
+        return TournamentStageTeam;
+    }(BaseModel));
+
+
+    (function (LeagueNewsType) {
+        LeagueNewsType[LeagueNewsType["text"] = 1] = "text";
+        LeagueNewsType[LeagueNewsType["video"] = 2] = "video";
+    })(exports.LeagueNewsType || (exports.LeagueNewsType = {}));
+    var LeagueNews = /** @class */ (function (_super) {
+        __extends(LeagueNews, _super);
+        function LeagueNews() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        LeagueNews.toFront = function (data) {
+            return undefined;
+        };
+        LeagueNews.toBack = function (data) { };
+        __decorate([
+            ToFrontHook
+        ], LeagueNews, "toFront", null);
+        __decorate([
+            ToBackHook
+        ], LeagueNews, "toBack", null);
+        LeagueNews = __decorate([
+            ModelInstance({
+                mappingFields: {
+                    id: 'id',
+                    title: 'title',
+                    datetime: 'datetime',
+                    preview_text: 'previewText',
+                    detail_text: 'detailText',
+                    picture: 'picture',
+                    cover: 'cover',
+                    mobile_picture: 'mobilePicture',
+                    is_main: 'isMain',
+                    tournaments: 'tournaments',
+                    type: 'type',
+                    video_link: 'videoLink',
+                    tag: 'tag',
+                },
+                relation: {
+                    datetime: DateTimeField,
+                    picture: File,
+                    cover: File,
+                    mobilePicture: File,
+                    tournaments: listField(Tournament),
+                    type: enumField(exports.LeagueNewsType),
+                }
+            })
+        ], LeagueNews);
+        return LeagueNews;
+    }(BaseModel));
+
+
+    (function (TournamentEventTypes) {
+        TournamentEventTypes[TournamentEventTypes["game_closed"] = 1] = "game_closed";
+        TournamentEventTypes[TournamentEventTypes["media_added"] = 2] = "media_added";
+        TournamentEventTypes[TournamentEventTypes["news"] = 3] = "news";
+    })(exports.TournamentEventTypes || (exports.TournamentEventTypes = {}));
+    var TournamentEvent = /** @class */ (function (_super) {
+        __extends(TournamentEvent, _super);
+        function TournamentEvent() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        TournamentEvent.toFront = function (data) { };
+        TournamentEvent.toBack = function (data) { };
+        __decorate([
+            ToFrontHook
+        ], TournamentEvent, "toFront", null);
+        __decorate([
+            ToBackHook
+        ], TournamentEvent, "toBack", null);
+        TournamentEvent = __decorate([
+            ModelInstance({
+                mappingFields: {
+                    id: 'id',
+                    game: 'game',
+                    news: 'news',
+                    league: 'league',
+                    tournaments: 'tournaments',
+                    event: 'event',
+                    datetime: 'datetime'
+                },
+                relation: {
+                    game: Game,
+                    news: LeagueNews,
+                    league: League,
+                    tournaments: listField(Tournament),
+                    datetime: DateField,
+                    event: enumField(exports.TournamentEventTypes)
+                }
+            })
+        ], TournamentEvent);
+        return TournamentEvent;
+    }(BaseModel));
+
+    var LeagueUserRoles;
+    (function (LeagueUserRoles) {
+        LeagueUserRoles[LeagueUserRoles["admin"] = 1] = "admin";
+        LeagueUserRoles[LeagueUserRoles["moderator"] = 2] = "moderator";
+        LeagueUserRoles[LeagueUserRoles["game_manager"] = 3] = "game_manager";
+    })(LeagueUserRoles || (LeagueUserRoles = {}));
+    var LeagueUserPermissions;
+    (function (LeagueUserPermissions) {
+        LeagueUserPermissions[LeagueUserPermissions["settings"] = 1] = "settings";
+        LeagueUserPermissions[LeagueUserPermissions["users"] = 2] = "users";
+        LeagueUserPermissions[LeagueUserPermissions["teams"] = 3] = "teams";
+        LeagueUserPermissions[LeagueUserPermissions["media"] = 4] = "media";
+        LeagueUserPermissions[LeagueUserPermissions["news"] = 5] = "news";
+        LeagueUserPermissions[LeagueUserPermissions["game_export"] = 6] = "game_export";
+        LeagueUserPermissions[LeagueUserPermissions["schedule"] = 7] = "schedule";
+        LeagueUserPermissions[LeagueUserPermissions["game_management"] = 8] = "game_management";
+    })(LeagueUserPermissions || (LeagueUserPermissions = {}));
+    var LeagueUser = /** @class */ (function (_super) {
+        __extends(LeagueUser, _super);
+        function LeagueUser() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        Object.defineProperty(LeagueUser.prototype, "role", {
+            get: function () {
+                return this._role;
+            },
+            set: function (value) {
+                this._role = LeagueUserRoles[value];
+            },
+            enumerable: true,
+            configurable: true
+        });
+        LeagueUser.toFront = function (data) { };
+        LeagueUser.toBack = function (data) { };
+        __decorate([
+            ToFrontHook
+        ], LeagueUser, "toFront", null);
+        __decorate([
+            ToBackHook
+        ], LeagueUser, "toBack", null);
+        LeagueUser = __decorate([
+            ModelInstance({
+                mappingFields: {
+                    id: 'id',
+                    user: 'user',
+                    role: 'role',
+                    permissions: 'permissions'
+                },
+                relation: {
+                    user: User,
+                    permissions: listField(enumField(LeagueUserPermissions))
+                }
+            })
+        ], LeagueUser);
+        return LeagueUser;
+    }(BaseModel));
+
+    var TournamentApi = /** @class */ (function () {
+        function TournamentApi(httpClient, configService) {
+            this.httpClient = httpClient;
+            this.configService = configService;
+        }
+        TournamentApi.prototype.getById = function (tournamentId) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament/" + tournamentId + "/")
+                            .pipe(operators.map(function (result) { return Tournament.toFront(result); }))
+                            .toPromise()];
+                });
+            });
+        };
+        TournamentApi.prototype.getByAlias = function (leagueId, alias) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/league/" + leagueId + "/tournaments/" + alias + "/")
+                            .pipe(operators.map(function (result) { return Tournament.toFront(result); }))
+                            .toPromise()];
+                });
+            });
+        };
+        TournamentApi.prototype.getNews = function (tournamentId) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament/" + tournamentId + "/news/")
+                            .pipe(operators.map(function (result) { return TournamentNews.toFront(result); }))
+                            .toPromise()];
+                });
+            });
+        };
+        TournamentApi.prototype.getEvents = function (tournamentId, page, size, filters) {
+            return __awaiter(this, void 0, void 0, function () {
+                var params;
+                return __generator(this, function (_a) {
+                    params = new http.HttpParams().set('page', page.toString())
+                        .set('size', size.toString());
+                    if (filters) {
+                        if (filters.event) {
+                            params = params.set('event', exports.TournamentEventTypes[filters.event]);
+                        }
+                        if (filters.search) {
+                            params = params.set('search', filters.search);
+                        }
+                        if (filters.tournamentTour) {
+                            params = params.set('tournament_tour', filters.tournamentTour.toString());
+                        }
+                    }
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament/" + tournamentId + "/events/", { params: params, observe: 'response' })
+                            .pipe(operators.map(function (result) { return ({
+                            total: +result.headers.get('X-Page-Count'),
+                            data: TournamentEvent.toFront(result.body)
+                        }); }))
+                            .toPromise()];
+                });
+            });
+        };
+        TournamentApi.prototype.getTournamentStages = function (tournamentId) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament/" + tournamentId + "/stages/").pipe(operators.map(function (data) { return TournamentStage.toFront(data); })).toPromise()];
+                });
+            });
+        };
+        TournamentApi.prototype.getPlayoff = function (tournamentId) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament/" + tournamentId + "/playoff/").pipe(operators.map(function (result) { return Playoff.toFront(result); })).toPromise()];
+                });
+            });
+        };
+        TournamentApi.prototype.getPlayoffGames = function (playoffId) {
+            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_playoff/" + playoffId + "/games/").pipe(operators.map(function (result) { return Game.toFront(result); })).toPromise()];
+                });
+            });
+        };
+        TournamentApi.prototype.getGamesStages = function (tournamentId) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament/" + tournamentId + "/games_stages/")
+                            .pipe(operators.map(function (data) { return GameTimelineStages.toFront(data); }))
+                            .toPromise()];
+                });
+            });
+        };
+        TournamentApi.prototype.getGames = function (tournamentId, page, size, filters) {
+            if (filters === void 0) { filters = {}; }
+            return __awaiter(this, void 0, void 0, function () {
+                var params;
+                return __generator(this, function (_a) {
+                    params = new http.HttpParams().set('page', page.toString());
+                    if (size) {
+                        params = params.set('size', size.toString());
+                    }
+                    params = applyGamesFilters(filters, params);
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament/" + tournamentId + "/games/", { params: params, observe: 'response' })
+                            .pipe(operators.map(function (result) { return ({
+                            total: +result.headers.get('X-Page-Count'),
+                            data: Game.toFront(result.body)
+                        }); })).toPromise()];
+                });
+            });
+        };
+        TournamentApi.prototype.getTeams = function (tournamentId) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament/" + tournamentId + "/teams/")
+                            .pipe(operators.map(function (result) { return TournamentTeam.toFront(result); }))
+                            .toPromise()];
+                });
+            });
+        };
+        TournamentApi.prototype.getStageTeams = function (tournamentId) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament/" + tournamentId + "/stage_teams/")
+                            .pipe(operators.map(function (result) { return TournamentStageTeam.toFront(result); }))
+                            .toPromise()];
+                });
+            });
+        };
+        TournamentApi.prototype.getTeamById = function (tournamentTeamId) {
+            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_team/" + tournamentTeamId + "/")
+                            .pipe(operators.map(function (result) { return TournamentTeam.toFront(result); }))
+                            .toPromise()];
+                });
+            });
+        };
+        TournamentApi.prototype.getUserById = function (userId) {
+            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_team_user/" + userId + "/")
+                            .pipe(operators.map(function (result) { return TournamentTeamUser.toFront(result); }))
+                            .toPromise()];
+                });
+            });
+        };
+        TournamentApi.prototype.getUserGames = function (tournamentUserId) {
+            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_team_user/" + tournamentUserId + "/games/")
+                            .pipe(operators.map(function (result) { return Game.toFront(result); }))
+                            .toPromise()];
+                });
+            });
+        };
+        TournamentApi.prototype.getBasketballStatistic = function (filters) {
+            return __awaiter(this, void 0, void 0, function () {
+                var params, _a, _b, key;
+                var e_1, _c;
+                return __generator(this, function (_d) {
+                    params = new http.HttpParams();
+                    if (filters) {
+                        try {
+                            for (_a = __values(Object.keys(filters)), _b = _a.next(); !_b.done; _b = _a.next()) {
+                                key = _b.value;
+                                if (filters[key]) {
+                                    params = params.set(key, filters[key]);
+                                }
+                            }
+                        }
+                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                        finally {
+                            try {
+                                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                            }
+                            finally { if (e_1) throw e_1.error; }
+                        }
+                        if (filters.per_game !== undefined) {
+                            params = params.set('per_game', filters.per_game ? '1' : '0');
+                        }
+                        if (filters.tournament_ids) {
+                            params = params.set('tournament_ids', filters.tournament_ids.join(','));
+                        }
+                    }
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/basketball_statistic/", { params: params }).pipe(operators.map(function (result) { return BasketballStatistic.toFront(result); })).toPromise()];
+                });
+            });
+        };
+        TournamentApi.prototype.getVolleyballStatistic = function (filters) {
+            return __awaiter(this, void 0, void 0, function () {
+                var params, _a, _b, key;
+                var e_2, _c;
+                return __generator(this, function (_d) {
+                    params = new http.HttpParams();
+                    if (filters) {
+                        try {
+                            for (_a = __values(Object.keys(filters)), _b = _a.next(); !_b.done; _b = _a.next()) {
+                                key = _b.value;
+                                if (filters[key]) {
+                                    params = params.set(key, filters[key]);
+                                }
+                            }
+                        }
+                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                        finally {
+                            try {
+                                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                            }
+                            finally { if (e_2) throw e_2.error; }
+                        }
+                        if (filters.per_game !== undefined) {
+                            params = params.set('per_game', filters.per_game ? '1' : '0');
+                        }
+                        if (filters.tournament_ids) {
+                            params = params.set('tournament_ids', filters.tournament_ids.join(','));
+                        }
+                    }
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/volleyball_statistic/", { params: params }).pipe(operators.map(function (result) { return VolleyballStatistic.toFront(result); })).toPromise()];
+                });
+            });
+        };
+        TournamentApi.prototype.getHockeyStatistic = function (filters) {
+            return __awaiter(this, void 0, void 0, function () {
+                var params, _a, _b, key;
+                var e_3, _c;
+                return __generator(this, function (_d) {
+                    params = new http.HttpParams();
+                    if (filters) {
+                        try {
+                            for (_a = __values(Object.keys(filters)), _b = _a.next(); !_b.done; _b = _a.next()) {
+                                key = _b.value;
+                                if (filters[key]) {
+                                    params = params.set(key, filters[key]);
+                                }
+                            }
+                        }
+                        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                        finally {
+                            try {
+                                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                            }
+                            finally { if (e_3) throw e_3.error; }
+                        }
+                        if (filters.per_game !== undefined) {
+                            params = params.set('per_game', filters.per_game ? '1' : '0');
+                        }
+                        if (filters.tournament_ids) {
+                            params = params.set('tournament_ids', filters.tournament_ids.join(','));
+                        }
+                    }
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/hockey_statistic/", { params: params }).pipe(operators.map(function (result) { return HockeyStatistic.toFront(result); })).toPromise()];
+                });
+            });
+        };
+        TournamentApi.prototype.getFootballStatistic = function (filters) {
+            return __awaiter(this, void 0, void 0, function () {
+                var params, _a, _b, key;
+                var e_4, _c;
+                return __generator(this, function (_d) {
+                    params = new http.HttpParams();
+                    if (filters) {
+                        try {
+                            for (_a = __values(Object.keys(filters)), _b = _a.next(); !_b.done; _b = _a.next()) {
+                                key = _b.value;
+                                if (filters[key]) {
+                                    params = params.set(key, filters[key]);
+                                }
+                            }
+                        }
+                        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                        finally {
+                            try {
+                                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                            }
+                            finally { if (e_4) throw e_4.error; }
+                        }
+                        if (filters.per_game !== undefined) {
+                            params = params.set('per_game', filters.per_game ? '1' : '0');
+                        }
+                        if (filters.tournament_ids) {
+                            params = params.set('tournament_ids', filters.tournament_ids.join(','));
+                        }
+                    }
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/football_statistic/", { params: params }).pipe(operators.map(function (result) { return FootballStatistic.toFront(result); })).toPromise()];
+                });
+            });
+        };
+        TournamentApi.prototype.getTournamentTeamUsers = function (tournamentTeamId) {
+            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_team/" + tournamentTeamId + "/users/").pipe(operators.map(function (result) { return TournamentTeamUser.toFront(result); })).toPromise()];
+                });
+            });
+        };
+        TournamentApi.prototype.myPermission = function (tournamentId) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament/" + tournamentId + "/permission/").pipe(operators.map(function (data) { return (data.permissions || []).map(function (item) { return LeagueUserPermissions[item]; }); })).toPromise()];
+                });
+            });
+        };
+        TournamentApi.prototype.getTournamentTeamTournaments = function (tournamentTeamId) {
+            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_team/" + tournamentTeamId + "/tournaments/").pipe(operators.map(function (result) { return Tournament.toFront(result); })).toPromise()];
+                });
+            });
+        };
+        TournamentApi.prototype.getTournamentUserTournaments = function (tournamentTeamUserId) {
+            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_team_user/" + tournamentTeamUserId + "/tournaments/").pipe(operators.map(function (result) { return Tournament.toFront(result); })).toPromise()];
+                });
+            });
+        };
+        TournamentApi.ctorParameters = function () { return [
+            { type: http.HttpClient },
+            { type: ConfigService }
+        ]; };
+        TournamentApi.ɵprov = core.ɵɵdefineInjectable({ factory: function TournamentApi_Factory() { return new TournamentApi(core.ɵɵinject(http.HttpClient), core.ɵɵinject(ConfigService)); }, token: TournamentApi, providedIn: "root" });
+        TournamentApi = __decorate([
+            core.Injectable({ providedIn: 'root' })
+        ], TournamentApi);
+        return TournamentApi;
+    }());
+    function applyGamesFilters(filters, params) {
+        if (filters.tournamentIds) {
+            params = params.set('tournament_ids', filters.tournamentIds.join(','));
+        }
+        if (filters.tournamentStageId) {
+            params = params.set('tournament_stage_id', filters.tournamentStageId.toString());
+        }
+        if (filters.tournamentTour) {
+            params = params.set('tournament_tour', filters.tournamentTour.toString());
+        }
+        if (filters.playoffStage) {
+            params = params.set('playoff_stage', filters.playoffStage.toString());
+        }
+        if (filters.teamId) {
+            params = params.set('team_id', filters.teamId.toString());
+        }
+        if (filters.status) {
+            params = params.set('status', exports.GameStatuses[filters.status]);
+        }
+        if (filters.statuses) {
+            var statuses = filters.statuses.map(function (i) { return exports.GameStatuses[i]; });
+            params = params.set('statuses', statuses.join(','));
+        }
+        if (filters.tournamentCourtId) {
+            params = params.set('tournament_court_id', filters.tournamentCourtId.toString());
+        }
+        if (filters.userId) {
+            params = params.set('user_id', filters.userId.toString());
+        }
+        return params;
+    }
+
+    var LeaguePartner = /** @class */ (function (_super) {
+        __extends(LeaguePartner, _super);
+        function LeaguePartner() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        LeaguePartner.toFront = function (data) { };
+        LeaguePartner.toBack = function (data) { };
+        __decorate([
+            ToFrontHook
+        ], LeaguePartner, "toFront", null);
+        __decorate([
+            ToBackHook
+        ], LeaguePartner, "toBack", null);
+        LeaguePartner = __decorate([
+            ModelInstance({
+                mappingFields: {
+                    id: 'id',
+                    title: 'title',
+                    picture: 'picture',
+                    link: 'link',
+                    sort: 'sort',
+                },
+                relation: {
+                    picture: File
+                }
+            })
+        ], LeaguePartner);
+        return LeaguePartner;
+    }(BaseModel));
+
+
+    (function (BannerLocation) {
+        BannerLocation["slider"] = "slider";
+        BannerLocation["central"] = "central";
+        BannerLocation["media"] = "media";
+    })(exports.BannerLocation || (exports.BannerLocation = {}));
+    var LeagueBanner = /** @class */ (function (_super) {
+        __extends(LeagueBanner, _super);
+        function LeagueBanner() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        LeagueBanner.toFront = function (data) {
+        };
+        LeagueBanner.toBack = function (data) {
+        };
+        __decorate([
+            ToFrontHook
+        ], LeagueBanner, "toFront", null);
+        __decorate([
+            ToBackHook
+        ], LeagueBanner, "toBack", null);
+        LeagueBanner = __decorate([
+            ModelInstance({
+                mappingFields: {
+                    id: 'id',
+                    title: 'title',
+                    picture: 'picture',
+                    link: 'link',
+                    sort: 'sort',
+                    location: 'location',
+                },
+                relation: {
+                    picture: File,
+                    location: enumField(exports.BannerLocation),
+                }
+            })
+        ], LeagueBanner);
+        return LeagueBanner;
+    }(BaseModel));
+
+    var LeagueApi = /** @class */ (function () {
+        function LeagueApi(httpClient, configService) {
+            this.httpClient = httpClient;
+            this.configService = configService;
+        }
+        LeagueApi.prototype.getByAlias = function (alias) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/league/" + alias + "/").pipe(operators.map(function (result) { return League.toFront(result); })).toPromise()];
                 });
             });
         };
@@ -3931,34 +4690,13 @@
         };
         LeagueApi.prototype.getGames = function (leagueId, page, size, filters) {
             return __awaiter(this, void 0, void 0, function () {
-                var params, statuses;
+                var params;
                 return __generator(this, function (_a) {
                     params = new http.HttpParams().set('page', page.toString());
                     if (size) {
                         params = params.set('size', size.toString());
                     }
-                    if (filters.tournamentStageId) {
-                        params = params.set('tournament_stage_id', filters.tournamentStageId.toString());
-                    }
-                    if (filters.tournamentTour) {
-                        params = params.set('tournament_tour', filters.tournamentTour.toString());
-                    }
-                    if (filters.playoffStage) {
-                        params = params.set('playoff_stage', filters.playoffStage.toString());
-                    }
-                    if (filters.teamId) {
-                        params = params.set('team_id', filters.teamId.toString());
-                    }
-                    if (filters.status) {
-                        params = params.set('status', exports.GameStatuses[filters.status]);
-                    }
-                    if (filters.statuses) {
-                        statuses = filters.statuses.map(function (i) { return exports.GameStatuses[i]; });
-                        params = params.set('statuses', statuses.join(','));
-                    }
-                    if (filters.tournamentCourtId) {
-                        params = params.set('tournament_court_id', filters.tournamentCourtId.toString());
-                    }
+                    params = applyGamesFilters(filters, params);
                     return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/league/" + leagueId + "/games/", { params: params, observe: 'response' }).pipe(operators.map(function (result) { return ({
                             total: +result.headers.get('X-Page-Count'),
                             data: Game.toFront(result.body)
@@ -4971,69 +5709,6 @@
         return TeamInviteExternal;
     }(BaseModel));
 
-    var VolleyballStatistic = /** @class */ (function (_super) {
-        __extends(VolleyballStatistic, _super);
-        function VolleyballStatistic() {
-            return _super !== null && _super.apply(this, arguments) || this;
-        }
-        VolleyballStatistic.toFront = function (data) { };
-        VolleyballStatistic.toBack = function (data) { };
-        __decorate([
-            ToFrontHook
-        ], VolleyballStatistic, "toFront", null);
-        __decorate([
-            ToBackHook
-        ], VolleyballStatistic, "toBack", null);
-        VolleyballStatistic = __decorate([
-            ModelInstance({
-                mappingFields: {
-                    team: 'team',
-                    team_user: 'teamUser',
-                    tournament_team_user: 'tournamentTeamUser',
-                    tournament_team: 'tournamentTeam',
-                    user: 'user',
-                    month: 'month',
-                    win_lose: 'winLose',
-                    games_count: 'gamesCount',
-                    won_games_count: 'wonGamesCount',
-                    serve_hits: 'serveHits',
-                    serve_faults: 'serveFaults',
-                    serve_aces: 'serveAces',
-                    serve_percent: 'servePercent',
-                    ace_percent: 'acePercent',
-                    stuff_blocks: 'stuffBlocks',
-                    block_faults: 'blockFaults',
-                    block_rebounds: 'blockRebounds',
-                    block_percent: 'blockPercent',
-                    attack_spikes: 'attackSpikes',
-                    attack_faults: 'attackFaults',
-                    attack_shots: 'attackShots',
-                    attack_percent: 'attackPercent',
-                    receives: 'receives',
-                    receive_faults: 'receiveFaults',
-                    excellent_receives: 'excellentReceives',
-                    receive_percent: 'receivePercent',
-                    serve_receives: 'serveReceives',
-                    serve_receive_faults: 'serveReceiveFaults',
-                    excellent_serve_receives: 'excellentServeReceives',
-                    serve_receive_percent: 'serveReceivePercent',
-                    points: 'points',
-                    faults: 'faults',
-                    newbie: 'newbie',
-                },
-                relation: {
-                    team: Team,
-                    teamUser: TeamUser,
-                    tournamentTeamUser: TournamentTeamUser,
-                    tournamentTeam: TournamentTeam,
-                    user: User,
-                    month: DateField,
-                }
-            })
-        ], VolleyballStatistic);
-        return VolleyballStatistic;
-    }(BaseStatistic));
-
 
     (function (TeamPermissionTypes) {
         TeamPermissionTypes[TeamPermissionTypes["for_all"] = 1] = "for_all";
@@ -5127,1203 +5802,544 @@
         }
         TeamApi.prototype.search = function (query, sportId) {
             return __awaiter(this, void 0, void 0, function () {
-                var params;
-                return __generator(this, function (_a) {
-                    params = (new http.HttpParams()).set('search', query);
-                    if (sportId) {
-                        params = params.set('sport', sportId.toString());
-                    }
-                    return [2 /*return*/, this.httpClient
-                            .get(this.configService.get('apiUrl') + "/api/v1/team/", { params: params })
-                            .pipe(operators.map(function (data) { return Team.toFront(data); }))
-                            .toPromise()];
-                });
-            });
-        };
-        TeamApi.prototype.create = function (team) {
-            return __awaiter(this, void 0, void 0, function () {
-                return __generator(this, function (_a) {
-                    return [2 /*return*/, this.httpClient
-                            .post(this.configService.get('apiUrl') + "/api/v1/team/", Team.toBack(team))
-                            .pipe(operators.map(function (data) { return Team.toFront(data); }))
-                            .toPromise()];
-                });
-            });
-        };
-        TeamApi.prototype.getById = function (teamId) {
-            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/team/" + teamId + "/")
-                            .pipe(operators.map(function (data) { return Team.toFront(data); }))
-                            .toPromise()];
-                });
-            });
-        };
-        TeamApi.prototype.getTeamAccess = function (teamId) {
-            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/team/" + teamId + "/access/")
-                            .pipe(operators.map(function (data) { return TeamAccess.toFront(data); }))
-                            .toPromise()];
-                });
-            });
-        };
-        TeamApi.prototype.update = function (teamId, values) {
-            return __awaiter(this, void 0, void 0, function () {
-                return __generator(this, function (_a) {
-                    return [2 /*return*/, this.httpClient
-                            .patch(this.configService.get('apiUrl') + "/api/v1/team/" + teamId + "/", Team.toBack(values))
-                            .pipe(operators.map(function (data) { return Team.toFront(data); }))
-                            .toPromise()];
-                });
-            });
-        };
-        TeamApi.prototype.delete = function (team) {
-            return __awaiter(this, void 0, void 0, function () {
-                return __generator(this, function (_a) {
-                    return [2 /*return*/, this.httpClient
-                            .delete(this.configService.get('apiUrl') + "/api/v1/team/" + team.id + "/")
-                            .toPromise()];
-                });
-            });
-        };
-        TeamApi.prototype.getPermission = function (teamId) {
-            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/team/" + teamId + "/permission/")
-                            .pipe(operators.map(function (data) { return TeamPermission.toFront(data); }))
-                            .toPromise()];
-                });
-            });
-        };
-        TeamApi.prototype.updatePermission = function (teamId, permission) {
-            return __awaiter(this, void 0, void 0, function () {
-                return __generator(this, function (_a) {
-                    return [2 /*return*/, this.httpClient
-                            .patch(this.configService.get('apiUrl') + "/api/v1/team/" + teamId + "/permission/", TeamPermission.toBack(permission))
-                            .pipe(operators.map(function (data) { return TeamPermission.toFront(data); }))
-                            .toPromise()];
-                });
-            });
-        };
-        TeamApi.prototype.getUsers = function (teamId, tournamentId) {
-            return __awaiter(this, void 0, void 0, function () {
-                var params;
-                return __generator(this, function (_a) {
-                    params = new http.HttpParams();
-                    if (tournamentId) {
-                        params = params.set('tournament_id', tournamentId.toString());
-                    }
-                    return [2 /*return*/, this.httpClient
-                            .get(this.configService.get('apiUrl') + "/api/v1/team/" + teamId + "/users/", { params: params })
-                            .pipe(operators.map(function (data) { return TeamUser.toFront(data); }))
-                            .toPromise()];
-                });
-            });
-        };
-        TeamApi.prototype.updateUserRole = function (teamId, teamUserId, role) {
-            return __awaiter(this, void 0, void 0, function () {
-                return __generator(this, function (_a) {
-                    return [2 /*return*/, this.httpClient
-                            .patch(this.configService.get('apiUrl') + "/api/v1/team/" + teamId + "/users/" + teamUserId + "/role/", { role: exports.TeamUserRole[role] })
-                            .pipe(operators.map(function (data) { return TeamUser.toFront(data); }))
-                            .toPromise()];
-                });
-            });
-        };
-        TeamApi.prototype.updateUserNumber = function (teamId, teamUserId, gameNumber) {
-            return __awaiter(this, void 0, void 0, function () {
-                return __generator(this, function (_a) {
-                    return [2 /*return*/, this.httpClient
-                            .patch(this.configService.get('apiUrl') + "/api/v1/team/" + teamId + "/users/" + teamUserId + "/number/", { number: gameNumber.toString() })
-                            .pipe(operators.map(function (data) { return TeamUser.toFront(data); }))
-                            .toPromise()];
-                });
-            });
-        };
-        TeamApi.prototype.deleteUser = function (teamUser) {
-            return __awaiter(this, void 0, void 0, function () {
-                return __generator(this, function (_a) {
-                    return [2 /*return*/, this.httpClient
-                            .delete(this.configService.get('apiUrl') + "/api/v1/team/" + teamUser.teamId + "/users/" + teamUser.id + "/")
-                            .toPromise()];
-                });
-            });
-        };
-        TeamApi.prototype.changeOwner = function (teamId, user) {
-            return __awaiter(this, void 0, void 0, function () {
-                return __generator(this, function (_a) {
-                    return [2 /*return*/, this.httpClient
-                            .post(this.configService.get('apiUrl') + "/api/v1/team/" + teamId + "/owner/", { id: user.id })
-                            .pipe(operators.map(function (data) { return Team.toFront(data); }))
-                            .toPromise()];
-                });
-            });
-        };
-        TeamApi.prototype.getInvites = function (teamId) {
-            return __awaiter(this, void 0, void 0, function () {
+                var params;
                 return __generator(this, function (_a) {
+                    params = (new http.HttpParams()).set('search', query);
+                    if (sportId) {
+                        params = params.set('sport', sportId.toString());
+                    }
                     return [2 /*return*/, this.httpClient
-                            .get(this.configService.get('apiUrl') + "/api/v1/team/" + teamId + "/invites/")
-                            .pipe(operators.map(function (data) { return TeamInvite.toFront(data); }))
+                            .get(this.configService.get('apiUrl') + "/api/v1/team/", { params: params })
+                            .pipe(operators.map(function (data) { return Team.toFront(data); }))
                             .toPromise()];
                 });
             });
         };
-        TeamApi.prototype.sendInvite = function (teamId, user) {
+        TeamApi.prototype.create = function (team) {
             return __awaiter(this, void 0, void 0, function () {
                 return __generator(this, function (_a) {
                     return [2 /*return*/, this.httpClient
-                            .post(this.configService.get('apiUrl') + "/api/v1/team/" + teamId + "/invites/", { user: user })
-                            .pipe(operators.map(function (data) { return TeamInvite.toFront(data); }))
+                            .post(this.configService.get('apiUrl') + "/api/v1/team/", Team.toBack(team))
+                            .pipe(operators.map(function (data) { return Team.toFront(data); }))
                             .toPromise()];
                 });
             });
         };
-        TeamApi.prototype.acceptInvite = function (invite) {
+        TeamApi.prototype.getById = function (teamId) {
             return __awaiter(this, void 0, void 0, function () {
                 return __generator(this, function (_a) {
                     return [2 /*return*/, this.httpClient
-                            .post(this.configService.get('apiUrl') + "/api/v1/team_invite/" + invite.id + "/accept/", {})
-                            .pipe(operators.map(function (data) { return TeamInvite.toFront(data); }))
+                            .get(this.configService.get('apiUrl') + "/api/v1/team/" + teamId + "/")
+                            .pipe(operators.map(function (data) { return Team.toFront(data); }))
                             .toPromise()];
                 });
             });
         };
-        TeamApi.prototype.declineInvite = function (invite) {
+        TeamApi.prototype.getTeamAccess = function (teamId) {
             return __awaiter(this, void 0, void 0, function () {
                 return __generator(this, function (_a) {
                     return [2 /*return*/, this.httpClient
-                            .post(this.configService.get('apiUrl') + "/api/v1/team_invite/" + invite.id + "/decline/", {})
-                            .pipe(operators.map(function (data) { return TeamInvite.toFront(data); }))
+                            .get(this.configService.get('apiUrl') + "/api/v1/team/" + teamId + "/access/")
+                            .pipe(operators.map(function (data) { return TeamAccess.toFront(data); }))
                             .toPromise()];
                 });
             });
         };
-        TeamApi.prototype.resendInvite = function (invite) {
+        TeamApi.prototype.update = function (teamId, values) {
             return __awaiter(this, void 0, void 0, function () {
                 return __generator(this, function (_a) {
                     return [2 /*return*/, this.httpClient
-                            .post(this.configService.get('apiUrl') + "/api/v1/team_invite/" + invite.id + "/resend/", {})
-                            .pipe(operators.map(function (data) { return TeamInvite.toFront(data); }))
+                            .patch(this.configService.get('apiUrl') + "/api/v1/team/" + teamId + "/", Team.toBack(values))
+                            .pipe(operators.map(function (data) { return Team.toFront(data); }))
                             .toPromise()];
                 });
             });
         };
-        TeamApi.prototype.getInvitesExternal = function (teamId) {
+        TeamApi.prototype.delete = function (team) {
             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/team/" + teamId + "/invites_external/")
-                            .pipe(operators.map(function (data) { return TeamInviteExternal.toFront(data); }))
+                            .delete(this.configService.get('apiUrl') + "/api/v1/team/" + team.id + "/")
                             .toPromise()];
                 });
             });
         };
-        TeamApi.prototype.sendInviteExternal = function (teamId, invite) {
+        TeamApi.prototype.getPermission = function (teamId) {
             return __awaiter(this, void 0, void 0, function () {
                 return __generator(this, function (_a) {
                     return [2 /*return*/, this.httpClient
-                            .post(this.configService.get('apiUrl') + "/api/v1/team/" + teamId + "/invites_external/", TeamInviteExternal.toBack(invite))
-                            .pipe(operators.map(function (data) { return TeamInviteExternal.toFront(data); }))
+                            .get(this.configService.get('apiUrl') + "/api/v1/team/" + teamId + "/permission/")
+                            .pipe(operators.map(function (data) { return TeamPermission.toFront(data); }))
                             .toPromise()];
                 });
             });
         };
-        TeamApi.prototype.deleteInviteExternal = function (invite) {
+        TeamApi.prototype.updatePermission = function (teamId, permission) {
             return __awaiter(this, void 0, void 0, function () {
                 return __generator(this, function (_a) {
                     return [2 /*return*/, this.httpClient
-                            .delete(this.configService.get('apiUrl') + "/api/v1/invites_external/" + invite.id + "/")
+                            .patch(this.configService.get('apiUrl') + "/api/v1/team/" + teamId + "/permission/", TeamPermission.toBack(permission))
+                            .pipe(operators.map(function (data) { return TeamPermission.toFront(data); }))
                             .toPromise()];
                 });
             });
         };
-        TeamApi.prototype.resendInviteExternal = function (invite) {
+        TeamApi.prototype.getUsers = function (teamId, tournamentId) {
             return __awaiter(this, void 0, void 0, function () {
+                var params;
                 return __generator(this, function (_a) {
+                    params = new http.HttpParams();
+                    if (tournamentId) {
+                        params = params.set('tournament_id', tournamentId.toString());
+                    }
                     return [2 /*return*/, this.httpClient
-                            .post(this.configService.get('apiUrl') + "/api/v1/invites_external/" + invite.id + "/resend/", {})
-                            .pipe(operators.map(function (data) { return TeamInviteExternal.toFront(data); }))
+                            .get(this.configService.get('apiUrl') + "/api/v1/team/" + teamId + "/users/", { params: params })
+                            .pipe(operators.map(function (data) { return TeamUser.toFront(data); }))
                             .toPromise()];
                 });
             });
         };
-        TeamApi.prototype.getPolls = function (teamId, archive) {
-            if (archive === void 0) { archive = false; }
+        TeamApi.prototype.updateUserRole = function (teamId, teamUserId, role) {
             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/team/" + teamId + "/polls/" + (archive ? '?archive=1' : ''))
-                            .pipe(operators.map(function (data) { return Poll.toFront(data); }))
+                            .patch(this.configService.get('apiUrl') + "/api/v1/team/" + teamId + "/users/" + teamUserId + "/role/", { role: exports.TeamUserRole[role] })
+                            .pipe(operators.map(function (data) { return TeamUser.toFront(data); }))
                             .toPromise()];
                 });
             });
         };
-        TeamApi.prototype.createPoll = function (teamId, poll) {
+        TeamApi.prototype.updateUserNumber = function (teamId, teamUserId, gameNumber) {
             return __awaiter(this, void 0, void 0, function () {
                 return __generator(this, function (_a) {
                     return [2 /*return*/, this.httpClient
-                            .post(this.configService.get('apiUrl') + "/api/v1/team/" + teamId + "/polls/", Poll.toBack(poll))
-                            .pipe(operators.map(function (data) { return Poll.toFront(data); }))
+                            .patch(this.configService.get('apiUrl') + "/api/v1/team/" + teamId + "/users/" + teamUserId + "/number/", { number: gameNumber.toString() })
+                            .pipe(operators.map(function (data) { return TeamUser.toFront(data); }))
                             .toPromise()];
                 });
             });
         };
-        TeamApi.prototype.getUsersStatistic = function (teamId) {
+        TeamApi.prototype.deleteUser = function (teamUser) {
             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/team/" + teamId + "/statistics/")
-                            .pipe(operators.map(function (data) { return BasketballStatistic.toFront(data); }))
+                            .delete(this.configService.get('apiUrl') + "/api/v1/team/" + teamUser.teamId + "/users/" + teamUser.id + "/")
                             .toPromise()];
                 });
             });
         };
-        TeamApi.prototype.getVolleyballStatistic = function (teamId) {
+        TeamApi.prototype.changeOwner = function (teamId, user) {
             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/team/" + teamId + "/volleyball_statistics/")
-                            .pipe(operators.map(function (data) { return VolleyballStatistic.toFront(data); }))
+                            .post(this.configService.get('apiUrl') + "/api/v1/team/" + teamId + "/owner/", { id: user.id })
+                            .pipe(operators.map(function (data) { return Team.toFront(data); }))
                             .toPromise()];
                 });
             });
         };
-        TeamApi.prototype.joinTeam = function (teamId) {
+        TeamApi.prototype.getInvites = function (teamId) {
             return __awaiter(this, void 0, void 0, function () {
                 return __generator(this, function (_a) {
                     return [2 /*return*/, this.httpClient
-                            .post(this.configService.get('apiUrl') + "/api/v1/team/" + teamId + "/join/", {})
+                            .get(this.configService.get('apiUrl') + "/api/v1/team/" + teamId + "/invites/")
                             .pipe(operators.map(function (data) { return TeamInvite.toFront(data); }))
                             .toPromise()];
                 });
             });
         };
-        TeamApi.prototype.leaveTeam = function (teamId) {
-            return __awaiter(this, void 0, void 0, function () {
-                return __generator(this, function (_a) {
-                    return [2 /*return*/, this.httpClient
-                            .post(this.configService.get('apiUrl') + "/api/v1/team/" + teamId + "/leave/", {})
-                            .toPromise()];
-                });
-            });
-        };
-        TeamApi.prototype.getGames = function (teamId, archive) {
-            if (archive === void 0) { archive = false; }
-            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/team/" + teamId + "/games/" + (archive ? '?archive=1' : ''))
-                            .pipe(operators.map(function (data) { return Game.toFront(data); }))
-                            .toPromise()];
-                });
-            });
-        };
-        TeamApi.prototype.createGame = function (teamId, game) {
-            return __awaiter(this, void 0, void 0, function () {
-                return __generator(this, function (_a) {
-                    return [2 /*return*/, this.httpClient
-                            .post(this.configService.get('apiUrl') + "/api/v1/team/" + teamId + "/games/", Game.toBack(game))
-                            .pipe(operators.map(function (data) { return Game.toFront(data); }))
-                            .toPromise()];
-                });
-            });
-        };
-        TeamApi.prototype.getTeamEvents = function (teamId) {
-            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/team/" + teamId + "/events/")
-                            .pipe(operators.map(function (data) { return TeamEvent.toFront(data); }))
-                            .toPromise()];
-                });
-            });
-        };
-        TeamApi.prototype.createTeamEvent = function (teamId, teamEvent) {
-            return __awaiter(this, void 0, void 0, function () {
-                return __generator(this, function (_a) {
-                    return [2 /*return*/, this.httpClient
-                            .post(this.configService.get('apiUrl') + "/api/v1/team/" + teamId + "/events/", TeamEvent.toBack(teamEvent))
-                            .pipe(operators.map(function (data) { return TeamEvent.toFront(data); }))
-                            .toPromise()];
-                });
-            });
-        };
-        TeamApi.prototype.getTournaments = function (teamId) {
-            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/team/" + teamId + "/tournaments/")
-                            .pipe(operators.map(function (data) { return Tournament.toFront(data); }))
-                            .toPromise()];
-                });
-            });
-        };
-        TeamApi.prototype.getTournamentTeams = function (teamId) {
-            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/team/" + teamId + "/tournament_teams/")
-                            .pipe(operators.map(function (data) { return TournamentTeam.toFront(data); }))
-                            .toPromise()];
-                });
-            });
-        };
-        TeamApi.prototype.getTournamentInvites = function (teamId) {
-            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/team/" + teamId + "/tournament_invites/")
-                            .pipe(operators.map(function (data) { return TournamentInvite.toFront(data); }))
-                            .toPromise()];
-                });
-            });
-        };
-        TeamApi.prototype.getTournamentGames = function (teamId, tournamentId, page, size) {
-            return __awaiter(this, void 0, void 0, function () {
-                var params;
-                return __generator(this, function (_a) {
-                    params = new http.HttpParams().set('page', page.toString());
-                    if (size) {
-                        params = params.set('size', size.toString());
-                    }
-                    return [2 /*return*/, this.httpClient
-                            .get(this.configService.get('apiUrl') + "/api/v1/team/" + teamId + "/tournaments/" + tournamentId + "/games/", { params: params, observe: 'response' })
-                            .pipe(operators.map(function (response) {
-                            return {
-                                total: +response.headers.get('X-Page-Count'),
-                                data: Game.toFront(response.body)
-                            };
-                        }))
-                            .toPromise()];
-                });
-            });
-        };
-        TeamApi.prototype.acceptTournamentInvite = function (inviteId) {
-            return __awaiter(this, void 0, void 0, function () {
-                return __generator(this, function (_a) {
-                    return [2 /*return*/, this.httpClient
-                            .post(this.configService.get('apiUrl') + "/api/v1/tournament_invite/" + inviteId + "/accept/", {})
-                            .pipe(operators.map(function (data) { return TournamentInvite.toFront(data); }))
-                            .toPromise()];
-                });
-            });
-        };
-        TeamApi.prototype.declineTournamentInvite = function (inviteId) {
-            return __awaiter(this, void 0, void 0, function () {
-                return __generator(this, function (_a) {
-                    return [2 /*return*/, this.httpClient
-                            .post(this.configService.get('apiUrl') + "/api/v1/tournament_invite/" + inviteId + "/decline/", {})
-                            .pipe(operators.map(function (data) { return TournamentInvite.toFront(data); }))
-                            .toPromise()];
-                });
-            });
-        };
-        TeamApi.prototype.registerLazyUser = function (teamId, userData) {
+        TeamApi.prototype.sendInvite = function (teamId, user) {
             return __awaiter(this, void 0, void 0, function () {
                 return __generator(this, function (_a) {
                     return [2 /*return*/, this.httpClient
-                            .post(this.configService.get('apiUrl') + "/api/v1/team/" + teamId + "/lazy_user/", { user: User.toBack(userData) })
-                            .pipe(operators.map(function (data) { return TeamUser.toFront(data); }))
+                            .post(this.configService.get('apiUrl') + "/api/v1/team/" + teamId + "/invites/", { user: user })
+                            .pipe(operators.map(function (data) { return TeamInvite.toFront(data); }))
                             .toPromise()];
                 });
             });
         };
-        TeamApi.prototype.getLazyUser = function (teamUserId) {
+        TeamApi.prototype.acceptInvite = function (invite) {
             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/lazy_user/" + teamUserId + "/")
-                            .pipe(operators.map(function (data) { return TeamUser.toFront(data); }))
+                            .post(this.configService.get('apiUrl') + "/api/v1/team_invite/" + invite.id + "/accept/", {})
+                            .pipe(operators.map(function (data) { return TeamInvite.toFront(data); }))
                             .toPromise()];
                 });
             });
         };
-        TeamApi.prototype.updateLazyUser = function (teamUserId, userData) {
+        TeamApi.prototype.declineInvite = function (invite) {
             return __awaiter(this, void 0, void 0, function () {
                 return __generator(this, function (_a) {
                     return [2 /*return*/, this.httpClient
-                            .patch(this.configService.get('apiUrl') + "/api/v1/lazy_user/" + teamUserId + "/", { user: User.toBack(userData) })
-                            .pipe(operators.map(function (data) { return TeamUser.toFront(data); }))
+                            .post(this.configService.get('apiUrl') + "/api/v1/team_invite/" + invite.id + "/decline/", {})
+                            .pipe(operators.map(function (data) { return TeamInvite.toFront(data); }))
                             .toPromise()];
                 });
             });
         };
-        TeamApi.prototype.deleteLazyUser = function (teamUserId) {
+        TeamApi.prototype.resendInvite = function (invite) {
             return __awaiter(this, void 0, void 0, function () {
                 return __generator(this, function (_a) {
                     return [2 /*return*/, this.httpClient
-                            .delete(this.configService.get('apiUrl') + "/api/v1/lazy_user/" + teamUserId + "/")
+                            .post(this.configService.get('apiUrl') + "/api/v1/team_invite/" + invite.id + "/resend/", {})
+                            .pipe(operators.map(function (data) { return TeamInvite.toFront(data); }))
                             .toPromise()];
                 });
             });
         };
-        TeamApi.prototype.resendLazyUserEmail = function (teamUserId) {
+        TeamApi.prototype.getInvitesExternal = function (teamId) {
             return __awaiter(this, void 0, void 0, function () {
                 return __generator(this, function (_a) {
                     return [2 /*return*/, this.httpClient
-                            .post(this.configService.get('apiUrl') + "/api/v1/lazy_user/" + teamUserId + "/resend_email/", {})
+                            .get(this.configService.get('apiUrl') + "/api/v1/team/" + teamId + "/invites_external/")
+                            .pipe(operators.map(function (data) { return TeamInviteExternal.toFront(data); }))
                             .toPromise()];
                 });
             });
         };
-        TeamApi.ctorParameters = function () { return [
-            { type: http.HttpClient },
-            { type: ConfigService }
-        ]; };
-        TeamApi.ɵprov = core.ɵɵdefineInjectable({ factory: function TeamApi_Factory() { return new TeamApi(core.ɵɵinject(http.HttpClient), core.ɵɵinject(ConfigService)); }, token: TeamApi, providedIn: "root" });
-        TeamApi = __decorate([
-            core.Injectable({ providedIn: 'root' })
-        ], TeamApi);
-        return TeamApi;
-    }());
-
-    var TeamEventApi = /** @class */ (function () {
-        function TeamEventApi(httpClient, configService) {
-            this.httpClient = httpClient;
-            this.configService = configService;
-        }
-        TeamEventApi.prototype.getTeamEvent = function (teamEventId) {
+        TeamApi.prototype.sendInviteExternal = function (teamId, invite) {
             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/team_event/" + teamEventId + "/")
-                            .pipe(operators.map(function (data) { return TeamEvent.toFront(data); }))
+                            .post(this.configService.get('apiUrl') + "/api/v1/team/" + teamId + "/invites_external/", TeamInviteExternal.toBack(invite))
+                            .pipe(operators.map(function (data) { return TeamInviteExternal.toFront(data); }))
                             .toPromise()];
                 });
             });
         };
-        TeamEventApi.prototype.updateTeamEvent = function (teamEvent) {
+        TeamApi.prototype.deleteInviteExternal = function (invite) {
             return __awaiter(this, void 0, void 0, function () {
                 return __generator(this, function (_a) {
                     return [2 /*return*/, this.httpClient
-                            .patch(this.configService.get('apiUrl') + "/api/v1/team_event/" + teamEvent.id + "/", TeamEvent.toBack(teamEvent))
-                            .pipe(operators.map(function (data) { return TeamEvent.toFront(data); }))
+                            .delete(this.configService.get('apiUrl') + "/api/v1/invites_external/" + invite.id + "/")
                             .toPromise()];
                 });
             });
         };
-        TeamEventApi.prototype.deleteTeamEvent = function (teamEventId) {
+        TeamApi.prototype.resendInviteExternal = function (invite) {
             return __awaiter(this, void 0, void 0, function () {
                 return __generator(this, function (_a) {
                     return [2 /*return*/, this.httpClient
-                            .delete(this.configService.get('apiUrl') + "/api/v1/team_event/" + teamEventId + "/")
+                            .post(this.configService.get('apiUrl') + "/api/v1/invites_external/" + invite.id + "/resend/", {})
+                            .pipe(operators.map(function (data) { return TeamInviteExternal.toFront(data); }))
                             .toPromise()];
                 });
             });
         };
-        TeamEventApi.prototype.getTeamEventInvites = function (teamEventId) {
+        TeamApi.prototype.getPolls = function (teamId, archive) {
+            if (archive === void 0) { archive = false; }
             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/team_event/" + teamEventId + "/invites/")
-                            .pipe(operators.map(function (data) { return TeamEventInvite.toFront(data); }))
+                            .get(this.configService.get('apiUrl') + "/api/v1/team/" + teamId + "/polls/" + (archive ? '?archive=1' : ''))
+                            .pipe(operators.map(function (data) { return Poll.toFront(data); }))
                             .toPromise()];
                 });
             });
         };
-        TeamEventApi.prototype.createTeamEventInvite = function (teamEventId, teamUserId) {
+        TeamApi.prototype.createPoll = function (teamId, poll) {
             return __awaiter(this, void 0, void 0, function () {
                 return __generator(this, function (_a) {
                     return [2 /*return*/, this.httpClient
-                            .post(this.configService.get('apiUrl') + "/api/v1/team_event/" + teamEventId + "/invites/", { team_user_id: teamUserId })
-                            .pipe(operators.map(function (data) { return TeamEventInvite.toFront(data); }))
+                            .post(this.configService.get('apiUrl') + "/api/v1/team/" + teamId + "/polls/", Poll.toBack(poll))
+                            .pipe(operators.map(function (data) { return Poll.toFront(data); }))
                             .toPromise()];
                 });
             });
         };
-        TeamEventApi.prototype.acceptTeamEventInvite = function (teamEventInvite) {
+        TeamApi.prototype.getUsersStatistic = function (teamId) {
             return __awaiter(this, void 0, void 0, function () {
                 return __generator(this, function (_a) {
                     return [2 /*return*/, this.httpClient
-                            .post(this.configService.get('apiUrl') + "/api/v1/team_event_invite/" + teamEventInvite.id + "/accept/", {})
-                            .pipe(operators.map(function (data) { return TeamEventInvite.toFront(data); }))
+                            .get(this.configService.get('apiUrl') + "/api/v1/team/" + teamId + "/statistics/")
+                            .pipe(operators.map(function (data) { return BasketballStatistic.toFront(data); }))
                             .toPromise()];
                 });
             });
         };
-        TeamEventApi.prototype.declineTeamEventInvite = function (teamEventInvite) {
+        TeamApi.prototype.getVolleyballStatistic = function (teamId) {
             return __awaiter(this, void 0, void 0, function () {
                 return __generator(this, function (_a) {
                     return [2 /*return*/, this.httpClient
-                            .post(this.configService.get('apiUrl') + "/api/v1/team_event_invite/" + teamEventInvite.id + "/decline/", {})
-                            .pipe(operators.map(function (data) { return TeamEventInvite.toFront(data); }))
+                            .get(this.configService.get('apiUrl') + "/api/v1/team/" + teamId + "/volleyball_statistics/")
+                            .pipe(operators.map(function (data) { return VolleyballStatistic.toFront(data); }))
                             .toPromise()];
                 });
             });
         };
-        TeamEventApi.ctorParameters = function () { return [
-            { type: http.HttpClient },
-            { type: ConfigService }
-        ]; };
-        TeamEventApi.ɵprov = core.ɵɵdefineInjectable({ factory: function TeamEventApi_Factory() { return new TeamEventApi(core.ɵɵinject(http.HttpClient), core.ɵɵinject(ConfigService)); }, token: TeamEventApi, providedIn: "root" });
-        TeamEventApi = __decorate([
-            core.Injectable({ providedIn: 'root' })
-        ], TeamEventApi);
-        return TeamEventApi;
-    }());
-
-    var TournamentNews = /** @class */ (function (_super) {
-        __extends(TournamentNews, _super);
-        function TournamentNews() {
-            return _super !== null && _super.apply(this, arguments) || this;
-        }
-        TournamentNews.toFront = function (data) { };
-        TournamentNews.toBack = function (data) { };
-        __decorate([
-            ToFrontHook
-        ], TournamentNews, "toFront", null);
-        __decorate([
-            ToBackHook
-        ], TournamentNews, "toBack", null);
-        TournamentNews = __decorate([
-            ModelInstance({
-                mappingFields: {
-                    id: 'id',
-                    title: 'title',
-                    picture: 'picture',
-                    text: 'text',
-                    author: 'author',
-                    created_at: 'createdAt',
-                },
-                relation: {
-                    picture: File,
-                    author: User,
-                    createdAt: DateTimeField,
-                }
-            })
-        ], TournamentNews);
-        return TournamentNews;
-    }(BaseModel));
-
-    var GameTimelineStageItem = /** @class */ (function () {
-        function GameTimelineStageItem() {
-        }
-        GameTimelineStageItem.toFront = function (data) { };
-        GameTimelineStageItem.toBack = function (data) { };
-        __decorate([
-            ToFrontHook
-        ], GameTimelineStageItem, "toFront", null);
-        __decorate([
-            ToBackHook
-        ], GameTimelineStageItem, "toBack", null);
-        GameTimelineStageItem = __decorate([
-            ModelInstance({
-                mappingFields: {
-                    stage_id: 'stageId',
-                    tours_count: 'toursCount',
-                    playoff_stages_count: 'playoffStagesCount',
-                }
-            })
-        ], GameTimelineStageItem);
-        return GameTimelineStageItem;
-    }());
-    var GameTimelineStages = /** @class */ (function (_super) {
-        __extends(GameTimelineStages, _super);
-        function GameTimelineStages() {
-            return _super !== null && _super.apply(this, arguments) || this;
-        }
-        GameTimelineStages.toFront = function (data) { };
-        GameTimelineStages.toBack = function (data) { };
-        __decorate([
-            ToFrontHook
-        ], GameTimelineStages, "toFront", null);
-        __decorate([
-            ToBackHook
-        ], GameTimelineStages, "toBack", null);
-        GameTimelineStages = __decorate([
-            ModelInstance({
-                mappingFields: {
-                    tours_count: 'toursCount',
-                    playoff_stages_count: 'playoffStagesCount',
-                    current_tour: 'currentTour',
-                    current_playoff_stage: 'currentPlayoffStage',
-                    stages: 'stages',
-                    tournament_stage_id: 'tournamentStageId',
-                },
-                relation: {
-                    stages: listField(GameTimelineStageItem)
-                }
-            })
-        ], GameTimelineStages);
-        return GameTimelineStages;
-    }(BaseModel));
-
-
-    (function (TournamentStageStatuses) {
-        TournamentStageStatuses[TournamentStageStatuses["open"] = 0] = "open";
-        TournamentStageStatuses[TournamentStageStatuses["in_progress"] = 1] = "in_progress";
-        TournamentStageStatuses[TournamentStageStatuses["closed"] = 2] = "closed";
-    })(exports.TournamentStageStatuses || (exports.TournamentStageStatuses = {}));
-    var TournamentStage = /** @class */ (function (_super) {
-        __extends(TournamentStage, _super);
-        function TournamentStage() {
-            return _super !== null && _super.apply(this, arguments) || this;
-        }
-        TournamentStage.toFront = function (data) { };
-        TournamentStage.toBack = function (data) { };
-        __decorate([
-            ToFrontHook
-        ], TournamentStage, "toFront", null);
-        __decorate([
-            ToBackHook
-        ], TournamentStage, "toBack", null);
-        TournamentStage = __decorate([
-            ModelInstance({
-                mappingFields: {
-                    id: 'id',
-                    name: 'name',
-                    date: 'date',
-                    tournament_id: 'tournamentId',
-                    status: 'status',
-                },
-                relation: {
-                    date: DateField,
-                    status: enumField(exports.TournamentStageStatuses)
-                }
-            })
-        ], TournamentStage);
-        return TournamentStage;
-    }(BaseModel));
-
-    function generateArray(length) {
-        if (length <= 0) {
-            return [];
-        }
-        return Array.apply(null, Array(length)).map(function (_, i) { return i + 1; });
-    }
-    function getArrayChunks(array, length) {
-        var chunks = [];
-        var chunkLength = Math.ceil(array.length / length);
-        if (chunkLength === 0) {
-            return [array];
-        }
-        for (var i = 0; i < chunkLength; i++) {
-            chunks.push(array.slice(i * length, (i + 1) * length));
-        }
-        return chunks;
-    }
-
-
-    (function (PlayoffTypes) {
-        PlayoffTypes["double_elimination"] = "double_elimination";
-        PlayoffTypes["elimination"] = "elimination";
-    })(exports.PlayoffTypes || (exports.PlayoffTypes = {}));
-    var PlayoffSettings = /** @class */ (function (_super) {
-        __extends(PlayoffSettings, _super);
-        function PlayoffSettings() {
-            return _super !== null && _super.apply(this, arguments) || this;
-        }
-        PlayoffSettings.toFront = function (data) { };
-        PlayoffSettings.toBack = function (data) { };
-        __decorate([
-            ToFrontHook
-        ], PlayoffSettings, "toFront", null);
-        __decorate([
-            ToBackHook
-        ], PlayoffSettings, "toBack", null);
-        PlayoffSettings = __decorate([
-            ModelInstance({
-                mappingFields: {
-                    rounds: 'rounds',
-                    final_rounds: 'finalRounds',
-                    third_place_rounds: 'thirdPlaceRounds',
-                    teams_count: 'teamsCount',
-                    type: 'type',
-                },
-                relation: {
-                    type: enumField(exports.PlayoffTypes)
-                }
-            })
-        ], PlayoffSettings);
-        return PlayoffSettings;
-    }(BaseModel));
-    var Playoff = /** @class */ (function (_super) {
-        __extends(Playoff, _super);
-        function Playoff() {
-            var _this = _super !== null && _super.apply(this, arguments) || this;
-            _this.stages = [];
-            return _this;
-        }
-        Playoff.toFront = function (data) { };
-        Playoff.toBack = function (data) { };
-        Object.defineProperty(Playoff.prototype, "stagesCount", {
-            get: function () {
-                return Math.log(this.settings.teamsCount) / Math.log(2);
-            },
-            enumerable: true,
-            configurable: true
-        });
-        Playoff.prototype.getPlayoffStages = function () {
-            var _this = this;
-            if (this.stages.length === 0 && this.settings.teamsCount) {
-                var stagesCount = Math.log(this.settings.teamsCount) / Math.log(2);
-                this.stages = generateArray(stagesCount).map(function (stage) {
-                    var playoffStage = _this.settings.teamsCount / Math.pow(2, stage);
-                    var title = '';
-                    if (playoffStage === 1) {
-                        title = 'Финал';
-                    }
-                    else {
-                        title = "1 / " + playoffStage;
-                    }
-                    return {
-                        value: stage,
-                        title: title
-                    };
+        TeamApi.prototype.joinTeam = function (teamId) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, this.httpClient
+                            .post(this.configService.get('apiUrl') + "/api/v1/team/" + teamId + "/join/", {})
+                            .pipe(operators.map(function (data) { return TeamInvite.toFront(data); }))
+                            .toPromise()];
                 });
-            }
-            return this.stages;
+            });
         };
-        __decorate([
-            ToFrontHook
-        ], Playoff, "toFront", null);
-        __decorate([
-            ToBackHook
-        ], Playoff, "toBack", null);
-        Playoff = __decorate([
-            ModelInstance({
-                mappingFields: {
-                    id: 'id',
-                    name: 'name',
-                    settings: 'settings',
-                    tournament_id: 'tournamentId',
-                    tournament_stage_id: 'tournamentStageId',
-                    is_official: 'isOfficial'
-                },
-                relation: {
-                    settings: PlayoffSettings
-                }
-            })
-        ], Playoff);
-        return Playoff;
-    }(BaseModel));
-
-    var TournamentStageTeam = /** @class */ (function (_super) {
-        __extends(TournamentStageTeam, _super);
-        function TournamentStageTeam() {
-            return _super !== null && _super.apply(this, arguments) || this;
-        }
-        Object.defineProperty(TournamentStageTeam.prototype, "gamesWonPercent", {
-            get: function () {
-                if (!this.gamesCount) {
-                    return 0;
-                }
-                return Math.floor(1000 * this.wonGamesCount / this.gamesCount) / 10;
-            },
-            enumerable: true,
-            configurable: true
-        });
-        TournamentStageTeam.toFront = function (data) { };
-        TournamentStageTeam.toBack = function (data) { };
-        __decorate([
-            ToFrontHook
-        ], TournamentStageTeam, "toFront", null);
-        __decorate([
-            ToBackHook
-        ], TournamentStageTeam, "toBack", null);
-        TournamentStageTeam = __decorate([
-            ModelInstance({
-                mappingFields: {
-                    id: 'id',
-                    tournament_team: 'tournamentTeam',
-                    group: 'group',
-                    tournament_stage_id: 'tournamentStageId',
-                    games_count: 'gamesCount',
-                    won_games_count: 'wonGamesCount',
-                    score_sum: 'scoreSum',
-                    missed_sum: 'missedSum',
-                    last_games_count: 'lastGamesCount',
-                    last_games_won: 'lastGamesWon',
-                    points: 'points',
-                    final_standing: 'finalStanding',
-                    received_points: 'receivedPoints',
-                },
-                relation: {
-                    tournamentTeam: TournamentTeam,
-                    group: TournamentGroup
-                }
-            })
-        ], TournamentStageTeam);
-        return TournamentStageTeam;
-    }(BaseModel));
-
-    var LeagueUserRoles;
-    (function (LeagueUserRoles) {
-        LeagueUserRoles[LeagueUserRoles["admin"] = 1] = "admin";
-        LeagueUserRoles[LeagueUserRoles["moderator"] = 2] = "moderator";
-        LeagueUserRoles[LeagueUserRoles["game_manager"] = 3] = "game_manager";
-    })(LeagueUserRoles || (LeagueUserRoles = {}));
-    var LeagueUserPermissions;
-    (function (LeagueUserPermissions) {
-        LeagueUserPermissions[LeagueUserPermissions["settings"] = 1] = "settings";
-        LeagueUserPermissions[LeagueUserPermissions["users"] = 2] = "users";
-        LeagueUserPermissions[LeagueUserPermissions["teams"] = 3] = "teams";
-        LeagueUserPermissions[LeagueUserPermissions["media"] = 4] = "media";
-        LeagueUserPermissions[LeagueUserPermissions["news"] = 5] = "news";
-        LeagueUserPermissions[LeagueUserPermissions["game_export"] = 6] = "game_export";
-        LeagueUserPermissions[LeagueUserPermissions["schedule"] = 7] = "schedule";
-        LeagueUserPermissions[LeagueUserPermissions["game_management"] = 8] = "game_management";
-    })(LeagueUserPermissions || (LeagueUserPermissions = {}));
-    var LeagueUser = /** @class */ (function (_super) {
-        __extends(LeagueUser, _super);
-        function LeagueUser() {
-            return _super !== null && _super.apply(this, arguments) || this;
-        }
-        Object.defineProperty(LeagueUser.prototype, "role", {
-            get: function () {
-                return this._role;
-            },
-            set: function (value) {
-                this._role = LeagueUserRoles[value];
-            },
-            enumerable: true,
-            configurable: true
-        });
-        LeagueUser.toFront = function (data) { };
-        LeagueUser.toBack = function (data) { };
-        __decorate([
-            ToFrontHook
-        ], LeagueUser, "toFront", null);
-        __decorate([
-            ToBackHook
-        ], LeagueUser, "toBack", null);
-        LeagueUser = __decorate([
-            ModelInstance({
-                mappingFields: {
-                    id: 'id',
-                    user: 'user',
-                    role: 'role',
-                    permissions: 'permissions'
-                },
-                relation: {
-                    user: User,
-                    permissions: listField(enumField(LeagueUserPermissions))
-                }
-            })
-        ], LeagueUser);
-        return LeagueUser;
-    }(BaseModel));
-
-    var TournamentApi = /** @class */ (function () {
-        function TournamentApi(httpClient, configService) {
-            this.httpClient = httpClient;
-            this.configService = configService;
-        }
-        TournamentApi.prototype.getById = function (tournamentId) {
+        TeamApi.prototype.leaveTeam = function (teamId) {
             return __awaiter(this, void 0, void 0, function () {
                 return __generator(this, function (_a) {
-                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament/" + tournamentId + "/")
-                            .pipe(operators.map(function (result) { return Tournament.toFront(result); }))
+                    return [2 /*return*/, this.httpClient
+                            .post(this.configService.get('apiUrl') + "/api/v1/team/" + teamId + "/leave/", {})
                             .toPromise()];
                 });
             });
         };
-        TournamentApi.prototype.getByAlias = function (leagueId, alias) {
+        TeamApi.prototype.getGames = function (teamId, archive) {
+            if (archive === void 0) { archive = false; }
             return __awaiter(this, void 0, void 0, function () {
                 return __generator(this, function (_a) {
-                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/league/" + leagueId + "/tournaments/" + alias + "/")
-                            .pipe(operators.map(function (result) { return Tournament.toFront(result); }))
+                    return [2 /*return*/, this.httpClient
+                            .get(this.configService.get('apiUrl') + "/api/v1/team/" + teamId + "/games/" + (archive ? '?archive=1' : ''))
+                            .pipe(operators.map(function (data) { return Game.toFront(data); }))
                             .toPromise()];
                 });
             });
         };
-        TournamentApi.prototype.getNews = function (tournamentId) {
+        TeamApi.prototype.createGame = function (teamId, game) {
             return __awaiter(this, void 0, void 0, function () {
                 return __generator(this, function (_a) {
-                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament/" + tournamentId + "/news/")
-                            .pipe(operators.map(function (result) { return TournamentNews.toFront(result); }))
+                    return [2 /*return*/, this.httpClient
+                            .post(this.configService.get('apiUrl') + "/api/v1/team/" + teamId + "/games/", Game.toBack(game))
+                            .pipe(operators.map(function (data) { return Game.toFront(data); }))
                             .toPromise()];
                 });
             });
         };
-        TournamentApi.prototype.getEvents = function (tournamentId, page, size, filters) {
+        TeamApi.prototype.getTeamEvents = function (teamId) {
             return __awaiter(this, void 0, void 0, function () {
-                var params;
                 return __generator(this, function (_a) {
-                    params = new http.HttpParams().set('page', page.toString())
-                        .set('size', size.toString());
-                    if (filters) {
-                        if (filters.event) {
-                            params = params.set('event', exports.TournamentEventTypes[filters.event]);
-                        }
-                        if (filters.search) {
-                            params = params.set('search', filters.search);
-                        }
-                        if (filters.tournamentTour) {
-                            params = params.set('tournament_tour', filters.tournamentTour.toString());
-                        }
-                    }
-                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament/" + tournamentId + "/events/", { params: params, observe: 'response' })
-                            .pipe(operators.map(function (result) { return ({
-                            total: +result.headers.get('X-Page-Count'),
-                            data: TournamentEvent.toFront(result.body)
-                        }); }))
+                    return [2 /*return*/, this.httpClient
+                            .get(this.configService.get('apiUrl') + "/api/v1/team/" + teamId + "/events/")
+                            .pipe(operators.map(function (data) { return TeamEvent.toFront(data); }))
                             .toPromise()];
                 });
             });
         };
-        TournamentApi.prototype.getTournamentStages = function (tournamentId) {
+        TeamApi.prototype.createTeamEvent = function (teamId, teamEvent) {
             return __awaiter(this, void 0, void 0, function () {
                 return __generator(this, function (_a) {
-                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament/" + tournamentId + "/stages/").pipe(operators.map(function (data) { return TournamentStage.toFront(data); })).toPromise()];
+                    return [2 /*return*/, this.httpClient
+                            .post(this.configService.get('apiUrl') + "/api/v1/team/" + teamId + "/events/", TeamEvent.toBack(teamEvent))
+                            .pipe(operators.map(function (data) { return TeamEvent.toFront(data); }))
+                            .toPromise()];
                 });
             });
         };
-        TournamentApi.prototype.getPlayoff = function (tournamentId) {
+        TeamApi.prototype.getTournaments = function (teamId) {
             return __awaiter(this, void 0, void 0, function () {
                 return __generator(this, function (_a) {
-                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament/" + tournamentId + "/playoff/").pipe(operators.map(function (result) { return Playoff.toFront(result); })).toPromise()];
+                    return [2 /*return*/, this.httpClient
+                            .get(this.configService.get('apiUrl') + "/api/v1/team/" + teamId + "/tournaments/")
+                            .pipe(operators.map(function (data) { return Tournament.toFront(data); }))
+                            .toPromise()];
                 });
             });
         };
-        TournamentApi.prototype.getPlayoffGames = function (playoffId) {
+        TeamApi.prototype.getTournamentTeams = function (teamId) {
             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_playoff/" + playoffId + "/games/").pipe(operators.map(function (result) { return Game.toFront(result); })).toPromise()];
+                    return [2 /*return*/, this.httpClient
+                            .get(this.configService.get('apiUrl') + "/api/v1/team/" + teamId + "/tournament_teams/")
+                            .pipe(operators.map(function (data) { return TournamentTeam.toFront(data); }))
+                            .toPromise()];
                 });
             });
         };
-        TournamentApi.prototype.getGamesStages = function (tournamentId) {
+        TeamApi.prototype.getTournamentInvites = function (teamId) {
             return __awaiter(this, void 0, void 0, function () {
                 return __generator(this, function (_a) {
-                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament/" + tournamentId + "/games_stages/")
-                            .pipe(operators.map(function (data) { return GameTimelineStages.toFront(data); }))
+                    return [2 /*return*/, this.httpClient
+                            .get(this.configService.get('apiUrl') + "/api/v1/team/" + teamId + "/tournament_invites/")
+                            .pipe(operators.map(function (data) { return TournamentInvite.toFront(data); }))
+                            .toPromise()];
+                });
+            });
+        };
+        TeamApi.prototype.getTournamentGames = function (teamId, tournamentId, page, size) {
+            return __awaiter(this, void 0, void 0, function () {
+                var params;
+                return __generator(this, function (_a) {
+                    params = new http.HttpParams().set('page', page.toString());
+                    if (size) {
+                        params = params.set('size', size.toString());
+                    }
+                    return [2 /*return*/, this.httpClient
+                            .get(this.configService.get('apiUrl') + "/api/v1/team/" + teamId + "/tournaments/" + tournamentId + "/games/", { params: params, observe: 'response' })
+                            .pipe(operators.map(function (response) {
+                            return {
+                                total: +response.headers.get('X-Page-Count'),
+                                data: Game.toFront(response.body)
+                            };
+                        }))
+                            .toPromise()];
+                });
+            });
+        };
+        TeamApi.prototype.acceptTournamentInvite = function (inviteId) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, this.httpClient
+                            .post(this.configService.get('apiUrl') + "/api/v1/tournament_invite/" + inviteId + "/accept/", {})
+                            .pipe(operators.map(function (data) { return TournamentInvite.toFront(data); }))
+                            .toPromise()];
+                });
+            });
+        };
+        TeamApi.prototype.declineTournamentInvite = function (inviteId) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, this.httpClient
+                            .post(this.configService.get('apiUrl') + "/api/v1/tournament_invite/" + inviteId + "/decline/", {})
+                            .pipe(operators.map(function (data) { return TournamentInvite.toFront(data); }))
                             .toPromise()];
                 });
             });
         };
-        TournamentApi.prototype.getGames = function (tournamentId, page, size, filters) {
-            if (filters === void 0) { filters = {}; }
+        TeamApi.prototype.registerLazyUser = function (teamId, userData) {
             return __awaiter(this, void 0, void 0, function () {
-                var params, statuses;
                 return __generator(this, function (_a) {
-                    params = new http.HttpParams().set('page', page.toString());
-                    if (size) {
-                        params = params.set('size', size.toString());
-                    }
-                    if (filters.tournamentStageId) {
-                        params = params.set('tournament_stage_id', filters.tournamentStageId.toString());
-                    }
-                    if (filters.tournamentTour) {
-                        params = params.set('tournament_tour', filters.tournamentTour.toString());
-                    }
-                    if (filters.playoffStage) {
-                        params = params.set('playoff_stage', filters.playoffStage.toString());
-                    }
-                    if (filters.teamId) {
-                        params = params.set('team_id', filters.teamId.toString());
-                    }
-                    if (filters.status) {
-                        params = params.set('status', exports.GameStatuses[filters.status]);
-                    }
-                    if (filters.statuses) {
-                        statuses = filters.statuses.map(function (i) { return exports.GameStatuses[i]; });
-                        params = params.set('statuses', statuses.join(','));
-                    }
-                    if (filters.tournamentCourtId) {
-                        params = params.set('tournament_court_id', filters.tournamentCourtId.toString());
-                    }
-                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament/" + tournamentId + "/games/", { params: params, observe: 'response' })
-                            .pipe(operators.map(function (result) { return ({
-                            total: +result.headers.get('X-Page-Count'),
-                            data: Game.toFront(result.body)
-                        }); })).toPromise()];
+                    return [2 /*return*/, this.httpClient
+                            .post(this.configService.get('apiUrl') + "/api/v1/team/" + teamId + "/lazy_user/", { user: User.toBack(userData) })
+                            .pipe(operators.map(function (data) { return TeamUser.toFront(data); }))
+                            .toPromise()];
                 });
             });
         };
-        TournamentApi.prototype.getTeams = function (tournamentId) {
+        TeamApi.prototype.getLazyUser = function (teamUserId) {
             return __awaiter(this, void 0, void 0, function () {
                 return __generator(this, function (_a) {
-                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament/" + tournamentId + "/teams/")
-                            .pipe(operators.map(function (result) { return TournamentTeam.toFront(result); }))
+                    return [2 /*return*/, this.httpClient
+                            .get(this.configService.get('apiUrl') + "/api/v1/lazy_user/" + teamUserId + "/")
+                            .pipe(operators.map(function (data) { return TeamUser.toFront(data); }))
                             .toPromise()];
                 });
             });
         };
-        TournamentApi.prototype.getStageTeams = function (tournamentId) {
+        TeamApi.prototype.updateLazyUser = function (teamUserId, userData) {
             return __awaiter(this, void 0, void 0, function () {
                 return __generator(this, function (_a) {
-                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament/" + tournamentId + "/stage_teams/")
-                            .pipe(operators.map(function (result) { return TournamentStageTeam.toFront(result); }))
+                    return [2 /*return*/, this.httpClient
+                            .patch(this.configService.get('apiUrl') + "/api/v1/lazy_user/" + teamUserId + "/", { user: User.toBack(userData) })
+                            .pipe(operators.map(function (data) { return TeamUser.toFront(data); }))
                             .toPromise()];
                 });
             });
         };
-        TournamentApi.prototype.getTeamById = function (tournamentTeamId) {
+        TeamApi.prototype.deleteLazyUser = function (teamUserId) {
             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_team/" + tournamentTeamId + "/")
-                            .pipe(operators.map(function (result) { return TournamentTeam.toFront(result); }))
+                    return [2 /*return*/, this.httpClient
+                            .delete(this.configService.get('apiUrl') + "/api/v1/lazy_user/" + teamUserId + "/")
                             .toPromise()];
                 });
             });
         };
-        TournamentApi.prototype.getUserById = function (userId) {
+        TeamApi.prototype.resendLazyUserEmail = function (teamUserId) {
             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_team_user/" + userId + "/")
-                            .pipe(operators.map(function (result) { return TournamentTeamUser.toFront(result); }))
+                    return [2 /*return*/, this.httpClient
+                            .post(this.configService.get('apiUrl') + "/api/v1/lazy_user/" + teamUserId + "/resend_email/", {})
                             .toPromise()];
                 });
             });
         };
-        TournamentApi.prototype.getUserGames = function (tournamentUserId) {
+        TeamApi.ctorParameters = function () { return [
+            { type: http.HttpClient },
+            { type: ConfigService }
+        ]; };
+        TeamApi.ɵprov = core.ɵɵdefineInjectable({ factory: function TeamApi_Factory() { return new TeamApi(core.ɵɵinject(http.HttpClient), core.ɵɵinject(ConfigService)); }, token: TeamApi, providedIn: "root" });
+        TeamApi = __decorate([
+            core.Injectable({ providedIn: 'root' })
+        ], TeamApi);
+        return TeamApi;
+    }());
+
+    var TeamEventApi = /** @class */ (function () {
+        function TeamEventApi(httpClient, configService) {
+            this.httpClient = httpClient;
+            this.configService = configService;
+        }
+        TeamEventApi.prototype.getTeamEvent = function (teamEventId) {
             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_team_user/" + tournamentUserId + "/games/")
-                            .pipe(operators.map(function (result) { return Game.toFront(result); }))
+                    return [2 /*return*/, this.httpClient
+                            .get(this.configService.get('apiUrl') + "/api/v1/team_event/" + teamEventId + "/")
+                            .pipe(operators.map(function (data) { return TeamEvent.toFront(data); }))
                             .toPromise()];
                 });
             });
         };
-        TournamentApi.prototype.getBasketballStatistic = function (filters) {
+        TeamEventApi.prototype.updateTeamEvent = function (teamEvent) {
             return __awaiter(this, void 0, void 0, function () {
-                var params, _a, _b, key;
-                var e_1, _c;
-                return __generator(this, function (_d) {
-                    params = new http.HttpParams();
-                    if (filters) {
-                        try {
-                            for (_a = __values(Object.keys(filters)), _b = _a.next(); !_b.done; _b = _a.next()) {
-                                key = _b.value;
-                                if (filters[key]) {
-                                    params = params.set(key, filters[key]);
-                                }
-                            }
-                        }
-                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                        finally {
-                            try {
-                                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
-                            }
-                            finally { if (e_1) throw e_1.error; }
-                        }
-                        if (filters.per_game !== undefined) {
-                            params = params.set('per_game', filters.per_game ? '1' : '0');
-                        }
-                    }
-                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/basketball_statistic/", { params: params }).pipe(operators.map(function (result) { return BasketballStatistic.toFront(result); })).toPromise()];
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, this.httpClient
+                            .patch(this.configService.get('apiUrl') + "/api/v1/team_event/" + teamEvent.id + "/", TeamEvent.toBack(teamEvent))
+                            .pipe(operators.map(function (data) { return TeamEvent.toFront(data); }))
+                            .toPromise()];
                 });
             });
         };
-        TournamentApi.prototype.getVolleyballStatistic = function (filters) {
+        TeamEventApi.prototype.deleteTeamEvent = function (teamEventId) {
             return __awaiter(this, void 0, void 0, function () {
-                var params, _a, _b, key;
-                var e_2, _c;
-                return __generator(this, function (_d) {
-                    params = new http.HttpParams();
-                    if (filters) {
-                        try {
-                            for (_a = __values(Object.keys(filters)), _b = _a.next(); !_b.done; _b = _a.next()) {
-                                key = _b.value;
-                                if (filters[key]) {
-                                    params = params.set(key, filters[key]);
-                                }
-                            }
-                        }
-                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                        finally {
-                            try {
-                                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
-                            }
-                            finally { if (e_2) throw e_2.error; }
-                        }
-                        if (filters.per_game !== undefined) {
-                            params = params.set('per_game', filters.per_game ? '1' : '0');
-                        }
-                    }
-                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/volleyball_statistic/", { params: params }).pipe(operators.map(function (result) { return VolleyballStatistic.toFront(result); })).toPromise()];
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, this.httpClient
+                            .delete(this.configService.get('apiUrl') + "/api/v1/team_event/" + teamEventId + "/")
+                            .toPromise()];
                 });
             });
         };
-        TournamentApi.prototype.getHockeyStatistic = function (filters) {
+        TeamEventApi.prototype.getTeamEventInvites = function (teamEventId) {
             return __awaiter(this, void 0, void 0, function () {
-                var params, _a, _b, key;
-                var e_3, _c;
-                return __generator(this, function (_d) {
-                    params = new http.HttpParams();
-                    if (filters) {
-                        try {
-                            for (_a = __values(Object.keys(filters)), _b = _a.next(); !_b.done; _b = _a.next()) {
-                                key = _b.value;
-                                if (filters[key]) {
-                                    params = params.set(key, filters[key]);
-                                }
-                            }
-                        }
-                        catch (e_3_1) { e_3 = { error: e_3_1 }; }
-                        finally {
-                            try {
-                                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
-                            }
-                            finally { if (e_3) throw e_3.error; }
-                        }
-                        if (filters.per_game !== undefined) {
-                            params = params.set('per_game', filters.per_game ? '1' : '0');
-                        }
-                    }
-                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/hockey_statistic/", { params: params }).pipe(operators.map(function (result) { return HockeyStatistic.toFront(result); })).toPromise()];
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, this.httpClient
+                            .get(this.configService.get('apiUrl') + "/api/v1/team_event/" + teamEventId + "/invites/")
+                            .pipe(operators.map(function (data) { return TeamEventInvite.toFront(data); }))
+                            .toPromise()];
                 });
             });
         };
-        TournamentApi.prototype.getFootballStatistic = function (filters) {
+        TeamEventApi.prototype.createTeamEventInvite = function (teamEventId, teamUserId) {
             return __awaiter(this, void 0, void 0, function () {
-                var params, _a, _b, key;
-                var e_4, _c;
-                return __generator(this, function (_d) {
-                    params = new http.HttpParams();
-                    if (filters) {
-                        try {
-                            for (_a = __values(Object.keys(filters)), _b = _a.next(); !_b.done; _b = _a.next()) {
-                                key = _b.value;
-                                if (filters[key]) {
-                                    params = params.set(key, filters[key]);
-                                }
-                            }
-                        }
-                        catch (e_4_1) { e_4 = { error: e_4_1 }; }
-                        finally {
-                            try {
-                                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
-                            }
-                            finally { if (e_4) throw e_4.error; }
-                        }
-                        if (filters.per_game !== undefined) {
-                            params = params.set('per_game', filters.per_game ? '1' : '0');
-                        }
-                    }
-                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/football_statistic/", { params: params }).pipe(operators.map(function (result) { return FootballStatistic.toFront(result); })).toPromise()];
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, this.httpClient
+                            .post(this.configService.get('apiUrl') + "/api/v1/team_event/" + teamEventId + "/invites/", { team_user_id: teamUserId })
+                            .pipe(operators.map(function (data) { return TeamEventInvite.toFront(data); }))
+                            .toPromise()];
                 });
             });
         };
-        TournamentApi.prototype.getTournamentTeamUsers = function (tournamentTeamId) {
+        TeamEventApi.prototype.acceptTeamEventInvite = function (teamEventInvite) {
             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_team/" + tournamentTeamId + "/users/").pipe(operators.map(function (result) { return TournamentTeamUser.toFront(result); })).toPromise()];
+                    return [2 /*return*/, this.httpClient
+                            .post(this.configService.get('apiUrl') + "/api/v1/team_event_invite/" + teamEventInvite.id + "/accept/", {})
+                            .pipe(operators.map(function (data) { return TeamEventInvite.toFront(data); }))
+                            .toPromise()];
                 });
             });
         };
-        TournamentApi.prototype.myPermission = function (tournamentId) {
+        TeamEventApi.prototype.declineTeamEventInvite = function (teamEventInvite) {
             return __awaiter(this, void 0, void 0, function () {
                 return __generator(this, function (_a) {
-                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament/" + tournamentId + "/permission/").pipe(operators.map(function (data) { return (data.permissions || []).map(function (item) { return LeagueUserPermissions[item]; }); })).toPromise()];
+                    return [2 /*return*/, this.httpClient
+                            .post(this.configService.get('apiUrl') + "/api/v1/team_event_invite/" + teamEventInvite.id + "/decline/", {})
+                            .pipe(operators.map(function (data) { return TeamEventInvite.toFront(data); }))
+                            .toPromise()];
                 });
             });
         };
-        TournamentApi.ctorParameters = function () { return [
+        TeamEventApi.ctorParameters = function () { return [
             { type: http.HttpClient },
             { type: ConfigService }
         ]; };
-        TournamentApi.ɵprov = core.ɵɵdefineInjectable({ factory: function TournamentApi_Factory() { return new TournamentApi(core.ɵɵinject(http.HttpClient), core.ɵɵinject(ConfigService)); }, token: TournamentApi, providedIn: "root" });
-        TournamentApi = __decorate([
+        TeamEventApi.ɵprov = core.ɵɵdefineInjectable({ factory: function TeamEventApi_Factory() { return new TeamEventApi(core.ɵɵinject(http.HttpClient), core.ɵɵinject(ConfigService)); }, token: TeamEventApi, providedIn: "root" });
+        TeamEventApi = __decorate([
             core.Injectable({ providedIn: 'root' })
-        ], TournamentApi);
-        return TournamentApi;
+        ], TeamEventApi);
+        return TeamEventApi;
     }());
 
     var TournamentJoinData = /** @class */ (function (_super) {
@@ -6461,34 +6477,13 @@
         };
         TournamentSeasonApi.prototype.getGames = function (seasonId, page, size, filters) {
             return __awaiter(this, void 0, void 0, function () {
-                var params, statuses;
+                var params;
                 return __generator(this, function (_a) {
                     params = new http.HttpParams().set('page', page.toString());
                     if (size) {
                         params = params.set('size', size.toString());
                     }
-                    if (filters.tournamentStageId) {
-                        params = params.set('tournament_stage_id', filters.tournamentStageId.toString());
-                    }
-                    if (filters.tournamentTour) {
-                        params = params.set('tournament_tour', filters.tournamentTour.toString());
-                    }
-                    if (filters.playoffStage) {
-                        params = params.set('playoff_stage', filters.playoffStage.toString());
-                    }
-                    if (filters.teamId) {
-                        params = params.set('team_id', filters.teamId.toString());
-                    }
-                    if (filters.status) {
-                        params = params.set('status', exports.GameStatuses[filters.status]);
-                    }
-                    if (filters.statuses) {
-                        statuses = filters.statuses.map(function (i) { return exports.GameStatuses[i]; });
-                        params = params.set('statuses', statuses.join(','));
-                    }
-                    if (filters.tournamentCourtId) {
-                        params = params.set('tournament_court_id', filters.tournamentCourtId.toString());
-                    }
+                    params = applyGamesFilters(filters, params);
                     return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament_season/" + seasonId + "/games/", { params: params, observe: 'response' }).pipe(operators.map(function (result) { return ({
                             total: +result.headers.get('X-Page-Count'),
                             data: Game.toFront(result.body)
@@ -7314,6 +7309,56 @@
         return VolleyballGameApi;
     }(GameBaseApi));
 
+    var PublicTeamApi = /** @class */ (function () {
+        function PublicTeamApi(httpClient, configService) {
+            this.httpClient = httpClient;
+            this.configService = configService;
+        }
+        PublicTeamApi.prototype.getById = function (teamId) {
+            return this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/public_team/" + teamId + "/").pipe(operators.map(function (result) { return Team.toFront(result); })).toPromise();
+        };
+        PublicTeamApi.prototype.getTournamentTeams = function (teamId, leagueId) {
+            var params = new http.HttpParams().set('league_id', leagueId.toString());
+            return this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/public_team/" + teamId + "/tournament_teams/", { params: params }).pipe(operators.map(function (result) { return TournamentTeam.toFront(result); })).toPromise();
+        };
+        PublicTeamApi.ctorParameters = function () { return [
+            { type: http.HttpClient },
+            { type: ConfigService }
+        ]; };
+        PublicTeamApi.ɵprov = core.ɵɵdefineInjectable({ factory: function PublicTeamApi_Factory() { return new PublicTeamApi(core.ɵɵinject(http.HttpClient), core.ɵɵinject(ConfigService)); }, token: PublicTeamApi, providedIn: "root" });
+        PublicTeamApi = __decorate([
+            core.Injectable({ providedIn: 'root' })
+        ], PublicTeamApi);
+        return PublicTeamApi;
+    }());
+
+    var PublicUserApi = /** @class */ (function () {
+        function PublicUserApi(httpClient, configService) {
+            this.httpClient = httpClient;
+            this.configService = configService;
+        }
+        PublicUserApi.prototype.getById = function (userId) {
+            return this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/public_user/" + userId + "/").pipe(operators.map(function (result) { return User.toFront(result); })).toPromise();
+        };
+        PublicUserApi.prototype.getTournaments = function (userId, leagueId) {
+            var params = new http.HttpParams().set('league_id', leagueId.toString());
+            return this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/public_user/" + userId + "/tournaments/", { params: params }).pipe(operators.map(function (result) { return Tournament.toFront(result); })).toPromise();
+        };
+        PublicUserApi.prototype.getTournamentUser = function (userId, seasonId) {
+            var params = new http.HttpParams().set('season_id', seasonId.toString());
+            return this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/public_user/" + userId + "/tournament_user/", { params: params }).pipe(operators.map(function (result) { return TournamentTeamUser.toFront(result); })).toPromise();
+        };
+        PublicUserApi.ctorParameters = function () { return [
+            { type: http.HttpClient },
+            { type: ConfigService }
+        ]; };
+        PublicUserApi.ɵprov = core.ɵɵdefineInjectable({ factory: function PublicUserApi_Factory() { return new PublicUserApi(core.ɵɵinject(http.HttpClient), core.ɵɵinject(ConfigService)); }, token: PublicUserApi, providedIn: "root" });
+        PublicUserApi = __decorate([
+            core.Injectable({ providedIn: 'root' })
+        ], PublicUserApi);
+        return PublicUserApi;
+    }());
+
     var _a$1;
     var BasketballGameLogTypeLocalization = (_a$1 = {},
         _a$1[exports.BasketballGameLogTypes.enter_game] = 'Выход на площадку',
@@ -8019,6 +8064,8 @@
     exports.Poll = Poll;
     exports.PollAnswer = PollAnswer;
     exports.PollVariant = PollVariant;
+    exports.PublicTeamApi = PublicTeamApi;
+    exports.PublicUserApi = PublicUserApi;
     exports.ReferenceApi = ReferenceApi;
     exports.SCORE_LOG_TYPES = SCORE_LOG_TYPES;
     exports.Sport = Sport;