@mtgame/core 0.0.2 → 0.0.4

package/bundles/mtgame-core.umd.js

@@ -1015,6 +1015,7 @@
                     recruitment_is_open: 'recruitmentIsOpen',
                     transfer_is_open: 'transferIsOpen',
                     basketball_statistic_type: 'basketballStatisticType',
+                    shot_clock_enabled: 'shotClockEnabled',
                 },
                 relation: {
                     type: enumField(exports.TournamentTypes),
@@ -1119,9 +1120,9 @@
 
 
     (function (OvertimeTypes) {
-        OvertimeTypes[OvertimeTypes["to_score_total"] = 0] = "to_score_total";
-        OvertimeTypes[OvertimeTypes["to_score_diff"] = 1] = "to_score_diff";
-        OvertimeTypes[OvertimeTypes["time"] = 2] = "time";
+        OvertimeTypes[OvertimeTypes["to_score_total"] = 1] = "to_score_total";
+        OvertimeTypes[OvertimeTypes["to_score_diff"] = 2] = "to_score_diff";
+        OvertimeTypes[OvertimeTypes["time"] = 3] = "time";
     })(exports.OvertimeTypes || (exports.OvertimeTypes = {}));
     var BasketballGameConfig = /** @class */ (function (_super) {
         __extends(BasketballGameConfig, _super);
@@ -1150,6 +1151,7 @@
                     overtime_timeout_count: 'overtimeTimeoutCount',
                     timeout_time: 'timeoutTime',
                     statistic_type: 'statisticType',
+                    shot_clock_enabled: 'shotClockEnabled'
                 },
                 relation: {
                     overtimeType: enumField(exports.OvertimeTypes),
@@ -2179,10 +2181,160 @@
         return BasketballGameApi;
     }());
 
+    var Feedback = /** @class */ (function () {
+        function Feedback() {
+        }
+        Feedback.toFront = function (data) {
+            return null;
+        };
+        Feedback.toBack = function (value) {
+            return null;
+        };
+        __decorate([
+            ToFrontHook
+        ], Feedback, "toFront", null);
+        __decorate([
+            ToBackHook
+        ], Feedback, "toBack", null);
+        Feedback = __decorate([
+            ModelInstance({
+                mappingFields: {
+                    id: 'id',
+                    theme: 'theme',
+                    message: 'message',
+                    files: 'files',
+                },
+                relation: {
+                    files: File
+                }
+            })
+        ], Feedback);
+        return Feedback;
+    }());
+
+    var FeedbackApi = /** @class */ (function () {
+        function FeedbackApi(httpClient, configService) {
+            this.httpClient = httpClient;
+            this.configService = configService;
+        }
+        FeedbackApi.prototype.sendFeedback = function (data) {
+            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/feedback/", Feedback.toBack(data))
+                            .pipe(operators.map(function (response) { return Feedback.toFront(response); }))
+                            .toPromise()];
+                });
+            });
+        };
+        FeedbackApi.ctorParameters = function () { return [
+            { type: http.HttpClient },
+            { type: ConfigService }
+        ]; };
+        FeedbackApi.ɵprov = core.ɵɵdefineInjectable({ factory: function FeedbackApi_Factory() { return new FeedbackApi(core.ɵɵinject(http.HttpClient), core.ɵɵinject(ConfigService)); }, token: FeedbackApi, providedIn: "root" });
+        FeedbackApi = __decorate([
+            core.Injectable({ providedIn: 'root' })
+        ], FeedbackApi);
+        return FeedbackApi;
+    }());
+
+    var FileApi = /** @class */ (function () {
+        function FileApi(httpClient, configService) {
+            this.httpClient = httpClient;
+            this.configService = configService;
+        }
+        FileApi.prototype.upload = function (fileData, filename) {
+            return __awaiter(this, void 0, void 0, function () {
+                var formData;
+                return __generator(this, function (_a) {
+                    formData = new FormData();
+                    formData.append('file', fileData, filename);
+                    return [2 /*return*/, this.httpClient
+                            .post(this.configService.get('apiUrl') + "/api/v1/file/", formData)
+                            .pipe(operators.map(function (data) { return File.toFront(data); }))
+                            .toPromise()];
+                });
+            });
+        };
+        FileApi.prototype.createZipArchive = function (files) {
+            return __awaiter(this, void 0, void 0, function () {
+                var formData, files_1, files_1_1, file;
+                var e_1, _a;
+                return __generator(this, function (_b) {
+                    formData = new FormData();
+                    try {
+                        for (files_1 = __values(files), files_1_1 = files_1.next(); !files_1_1.done; files_1_1 = files_1.next()) {
+                            file = files_1_1.value;
+                            formData.append('files', file.file, file.filename);
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (files_1_1 && !files_1_1.done && (_a = files_1.return)) _a.call(files_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                    return [2 /*return*/, this.httpClient
+                            .post(this.configService.get('apiUrl') + "/api/v1/file/zip_archive/", formData, { responseType: 'blob' })
+                            .toPromise()];
+                });
+            });
+        };
+        FileApi.ctorParameters = function () { return [
+            { type: http.HttpClient },
+            { type: ConfigService }
+        ]; };
+        FileApi.ɵprov = core.ɵɵdefineInjectable({ factory: function FileApi_Factory() { return new FileApi(core.ɵɵinject(http.HttpClient), core.ɵɵinject(ConfigService)); }, token: FileApi, providedIn: "root" });
+        FileApi = __decorate([
+            core.Injectable({ providedIn: 'root' })
+        ], FileApi);
+        return FileApi;
+    }());
+
+    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',
+                    is_main: 'isMain',
+                    tournaments: 'tournaments',
+                },
+                relation: {
+                    datetime: DateTimeField,
+                    picture: File,
+                    cover: File,
+                    tournaments: listField(Tournament)
+                }
+            })
+        ], 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);
@@ -2202,13 +2354,17 @@
                 mappingFields: {
                     id: 'id',
                     game: 'game',
-                    tournament: 'tournament',
+                    news: 'news',
+                    league: 'league',
+                    tournaments: 'tournaments',
                     event: 'event',
                     datetime: 'datetime'
                 },
                 relation: {
                     game: Game,
-                    tournament: Tournament,
+                    news: LeagueNews,
+                    league: League,
+                    tournaments: listField(Tournament),
                     datetime: DateField,
                     event: enumField(exports.TournamentEventTypes)
                 }
@@ -2275,6 +2431,64 @@
         return LeagueApi;
     }());
 
+    var LeagueNewsApi = /** @class */ (function () {
+        function LeagueNewsApi(httpClient, configService) {
+            this.httpClient = httpClient;
+            this.configService = configService;
+        }
+        LeagueNewsApi.prototype.getLeagueNewsList = function (leagueId) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/league/" + leagueId + "/news/", { observe: 'response' })
+                            .pipe(operators.map(function (response) { return ({
+                            total: +response.headers.get('X-Page-Count'),
+                            data: LeagueNews.toFront(response.body)
+                        }); }))
+                            .toPromise()];
+                });
+            });
+        };
+        LeagueNewsApi.prototype.getMainLeagueNews = function (leagueId) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/league/" + leagueId + "/news/?is_main=true")
+                            .pipe(operators.map(function (response) { return response && response.length > 0 ? LeagueNews.toFront(response[0]) : null; }))
+                            .toPromise()];
+                });
+            });
+        };
+        LeagueNewsApi.prototype.getNewsById = function (newsId) {
+            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_news/" + newsId)
+                            .pipe(operators.map(function (response) { return LeagueNews.toFront(response); }))
+                            .toPromise()];
+                });
+            });
+        };
+        LeagueNewsApi.prototype.getTournamentNewsList = 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/", { observe: 'response' })
+                            .pipe(operators.map(function (response) { return ({
+                            total: +response.headers.get('X-Page-Count'),
+                            data: LeagueNews.toFront(response.body)
+                        }); }))
+                            .toPromise()];
+                });
+            });
+        };
+        LeagueNewsApi.ctorParameters = function () { return [
+            { type: http.HttpClient },
+            { type: ConfigService }
+        ]; };
+        LeagueNewsApi.ɵprov = core.ɵɵdefineInjectable({ factory: function LeagueNewsApi_Factory() { return new LeagueNewsApi(core.ɵɵinject(http.HttpClient), core.ɵɵinject(ConfigService)); }, token: LeagueNewsApi, providedIn: "root" });
+        LeagueNewsApi = __decorate([
+            core.Injectable({ providedIn: 'root' })
+        ], LeagueNewsApi);
+        return LeagueNewsApi;
+    }());
+
     var MediaApi = /** @class */ (function () {
         function MediaApi(httpClient, configService) {
             this.httpClient = httpClient;
@@ -3108,733 +3322,1787 @@
         return ReferenceApi;
     }());
 
-    var TournamentNews = /** @class */ (function (_super) {
-        __extends(TournamentNews, _super);
-        function TournamentNews() {
+    var TeamInviteExternal = /** @class */ (function (_super) {
+        __extends(TeamInviteExternal, _super);
+        function TeamInviteExternal() {
             return _super !== null && _super.apply(this, arguments) || this;
         }
-        TournamentNews.toFront = function (data) { };
-        TournamentNews.toBack = function (data) { };
+        TeamInviteExternal.toFront = function (data) { };
+        TeamInviteExternal.toBack = function (data) { };
         __decorate([
             ToFrontHook
-        ], TournamentNews, "toFront", null);
+        ], TeamInviteExternal, "toFront", null);
         __decorate([
             ToBackHook
-        ], TournamentNews, "toBack", null);
-        TournamentNews = __decorate([
+        ], TeamInviteExternal, "toBack", null);
+        TeamInviteExternal = __decorate([
             ModelInstance({
                 mappingFields: {
                     id: 'id',
-                    title: 'title',
-                    picture: 'picture',
-                    text: 'text',
-                    author: 'author',
-                    created_at: 'createdAt',
+                    team_id: 'teamId',
+                    email: 'email',
+                    first_name: 'firstName',
+                    last_name: 'lastName',
                 },
-                relation: {
-                    picture: File,
-                    author: User,
-                    createdAt: DateTimeField,
-                }
             })
-        ], TournamentNews);
-        return TournamentNews;
+        ], TeamInviteExternal);
+        return TeamInviteExternal;
     }(BaseModel));
 
-    var GameTimelineStageItem = /** @class */ (function () {
-        function GameTimelineStageItem() {
+    var VolleyballStatistic = /** @class */ (function (_super) {
+        __extends(VolleyballStatistic, _super);
+        function VolleyballStatistic() {
+            return _super !== null && _super.apply(this, arguments) || this;
         }
-        GameTimelineStageItem.toFront = function (data) { };
-        GameTimelineStageItem.toBack = function (data) { };
+        VolleyballStatistic.toFront = function (data) { };
+        VolleyballStatistic.toBack = function (data) { };
         __decorate([
             ToFrontHook
-        ], GameTimelineStageItem, "toFront", null);
+        ], VolleyballStatistic, "toFront", null);
         __decorate([
             ToBackHook
-        ], GameTimelineStageItem, "toBack", null);
-        GameTimelineStageItem = __decorate([
+        ], VolleyballStatistic, "toBack", null);
+        VolleyballStatistic = __decorate([
             ModelInstance({
                 mappingFields: {
-                    stage_id: 'stageId',
-                    tours_count: 'toursCount',
-                    playoff_stages_count: 'playoffStagesCount',
+                    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,
                 }
             })
-        ], GameTimelineStageItem);
-        return GameTimelineStageItem;
-    }());
-    var GameTimelineStages = /** @class */ (function (_super) {
-        __extends(GameTimelineStages, _super);
-        function GameTimelineStages() {
+        ], VolleyballStatistic);
+        return VolleyballStatistic;
+    }(BaseModel));
+
+
+    (function (TeamPermissionTypes) {
+        TeamPermissionTypes[TeamPermissionTypes["for_all"] = 1] = "for_all";
+        TeamPermissionTypes[TeamPermissionTypes["for_users"] = 2] = "for_users";
+        TeamPermissionTypes[TeamPermissionTypes["for_team"] = 3] = "for_team";
+    })(exports.TeamPermissionTypes || (exports.TeamPermissionTypes = {}));
+    var TeamPermission = /** @class */ (function (_super) {
+        __extends(TeamPermission, _super);
+        function TeamPermission() {
             return _super !== null && _super.apply(this, arguments) || this;
         }
-        GameTimelineStages.toFront = function (data) { };
-        GameTimelineStages.toBack = function (data) { };
+        TeamPermission.toFront = function (data) { };
+        TeamPermission.toBack = function (data) { };
         __decorate([
             ToFrontHook
-        ], GameTimelineStages, "toFront", null);
+        ], TeamPermission, "toFront", null);
         __decorate([
             ToBackHook
-        ], GameTimelineStages, "toBack", null);
-        GameTimelineStages = __decorate([
+        ], TeamPermission, "toBack", null);
+        TeamPermission = __decorate([
             ModelInstance({
                 mappingFields: {
-                    tours_count: 'toursCount',
-                    playoff_stages_count: 'playoffStagesCount',
-                    current_tour: 'currentTour',
-                    current_playoff_stage: 'currentPlayoffStage',
-                    stages: 'stages',
-                    tournament_stage_id: 'tournamentStageId',
+                    players: 'players',
+                    games: 'games',
+                    statistic: 'statistic',
+                    polls: 'polls',
+                    events: 'events'
                 },
                 relation: {
-                    stages: listField(GameTimelineStageItem)
+                    players: enumField(exports.TeamPermissionTypes),
+                    games: enumField(exports.TeamPermissionTypes),
+                    statistic: enumField(exports.TeamPermissionTypes),
+                    polls: enumField(exports.TeamPermissionTypes),
+                    events: enumField(exports.TeamPermissionTypes)
                 }
             })
-        ], GameTimelineStages);
-        return GameTimelineStages;
+        ], TeamPermission);
+        return TeamPermission;
     }(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() {
+    var TeamAccess = /** @class */ (function (_super) {
+        __extends(TeamAccess, _super);
+        function TeamAccess() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        TeamAccess.toFront = function (data) { };
+        TeamAccess.toBack = function (data) { };
+        __decorate([
+            ToFrontHook
+        ], TeamAccess, "toFront", null);
+        __decorate([
+            ToBackHook
+        ], TeamAccess, "toBack", null);
+        TeamAccess = __decorate([
+            ModelInstance({
+                mappingFields: {
+                    can_edit: 'canEdit',
+                    can_view_users: 'canViewUsers',
+                    can_manage_permission: 'canManagePermission',
+                    can_change_owner: 'canChangeOwner',
+                    can_delete: 'canDelete',
+                    can_manage_invites: 'canManageInvites',
+                    can_view_invites: 'canViewInvites',
+                    can_manage_polls: 'canManagePolls',
+                    can_view_polls: 'canViewPolls',
+                    can_answer_poll: 'canAnswerPoll',
+                    can_manage_games: 'canManageGames',
+                    can_view_games: 'canViewGames',
+                    can_view_statistic: 'canViewStatistic',
+                    can_promote_users: 'canPromoteUsers',
+                    can_edit_users: 'canEditUsers',
+                    can_delete_users: 'canDeleteUsers',
+                    can_view_events: 'canViewEvents',
+                    can_manage_events: 'canManageEvents',
+                    can_view_tournaments: 'canViewTournaments',
+                    can_manage_tournaments: 'canManageTournaments',
+                    role: 'role'
+                },
+                relation: {
+                    role: enumField(exports.TeamUserRole)
+                }
+            })
+        ], TeamAccess);
+        return TeamAccess;
+    }(BaseModel));
+
+    var TeamApi = /** @class */ (function () {
+        function TeamApi(httpClient, configService) {
+            this.httpClient = httpClient;
+            this.configService = configService;
+        }
+        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 () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, this.httpClient
+                            .get(this.configService.get('apiUrl') + "/api/v1/team/" + teamId + "/invites/")
+                            .pipe(operators.map(function (data) { return TeamInvite.toFront(data); }))
+                            .toPromise()];
+                });
+            });
+        };
+        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 + "/invites/", { user: user })
+                            .pipe(operators.map(function (data) { return TeamInvite.toFront(data); }))
+                            .toPromise()];
+                });
+            });
+        };
+        TeamApi.prototype.acceptInvite = function (invite) {
+            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); }))
+                            .toPromise()];
+                });
+            });
+        };
+        TeamApi.prototype.declineInvite = function (invite) {
+            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); }))
+                            .toPromise()];
+                });
+            });
+        };
+        TeamApi.prototype.resendInvite = function (invite) {
+            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); }))
+                            .toPromise()];
+                });
+            });
+        };
+        TeamApi.prototype.getInvitesExternal = 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 + "/invites_external/")
+                            .pipe(operators.map(function (data) { return TeamInviteExternal.toFront(data); }))
+                            .toPromise()];
+                });
+            });
+        };
+        TeamApi.prototype.sendInviteExternal = function (teamId, invite) {
+            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); }))
+                            .toPromise()];
+                });
+            });
+        };
+        TeamApi.prototype.deleteInviteExternal = 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/invites_external/" + invite.id + "/")
+                            .toPromise()];
+                });
+            });
+        };
+        TeamApi.prototype.resendInviteExternal = function (invite) {
+            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/invites_external/" + invite.id + "/resend/", {})
+                            .pipe(operators.map(function (data) { return TeamInviteExternal.toFront(data); }))
+                            .toPromise()];
+                });
+            });
+        };
+        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/" + teamId + "/polls/" + (archive ? '?archive=1' : ''))
+                            .pipe(operators.map(function (data) { return Poll.toFront(data); }))
+                            .toPromise()];
+                });
+            });
+        };
+        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/" + teamId + "/polls/", Poll.toBack(poll))
+                            .pipe(operators.map(function (data) { return Poll.toFront(data); }))
+                            .toPromise()];
+                });
+            });
+        };
+        TeamApi.prototype.getUsersStatistic = 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 + "/statistics/")
+                            .pipe(operators.map(function (data) { return BasketballStatistic.toFront(data); }))
+                            .toPromise()];
+                });
+            });
+        };
+        TeamApi.prototype.getVolleyballStatistic = 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 + "/volleyball_statistics/")
+                            .pipe(operators.map(function (data) { return VolleyballStatistic.toFront(data); }))
+                            .toPromise()];
+                });
+            });
+        };
+        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()];
+                });
+            });
+        };
+        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) {
+            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); }))
+                            .toPromise()];
+                });
+            });
+        };
+        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/lazy_user/" + teamUserId + "/")
+                            .pipe(operators.map(function (data) { return TeamUser.toFront(data); }))
+                            .toPromise()];
+                });
+            });
+        };
+        TeamApi.prototype.updateLazyUser = function (teamUserId, userData) {
+            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); }))
+                            .toPromise()];
+                });
+            });
+        };
+        TeamApi.prototype.deleteLazyUser = function (teamUserId) {
+            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 + "/")
+                            .toPromise()];
+                });
+            });
+        };
+        TeamApi.prototype.resendLazyUserEmail = function (teamUserId) {
+            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/", {})
+                            .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) {
+            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); }))
+                            .toPromise()];
+                });
+            });
+        };
+        TeamEventApi.prototype.updateTeamEvent = function (teamEvent) {
+            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); }))
+                            .toPromise()];
+                });
+            });
+        };
+        TeamEventApi.prototype.deleteTeamEvent = function (teamEventId) {
+            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 + "/")
+                            .toPromise()];
+                });
+            });
+        };
+        TeamEventApi.prototype.getTeamEventInvites = 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/team_event/" + teamEventId + "/invites/")
+                            .pipe(operators.map(function (data) { return TeamEventInvite.toFront(data); }))
+                            .toPromise()];
+                });
+            });
+        };
+        TeamEventApi.prototype.createTeamEventInvite = function (teamEventId, teamUserId) {
+            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); }))
+                            .toPromise()];
+                });
+            });
+        };
+        TeamEventApi.prototype.acceptTeamEventInvite = function (teamEventInvite) {
+            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); }))
+                            .toPromise()];
+                });
+            });
+        };
+        TeamEventApi.prototype.declineTeamEventInvite = function (teamEventInvite) {
+            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); }))
+                            .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);
+        ], 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;
+    }
+
+    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'
+                }
+            })
+        ], 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
+                    };
+                });
+            }
+            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 TournamentApi = /** @class */ (function () {
+        function TournamentApi(httpClient, configService) {
+            this.httpClient = httpClient;
+            this.configService = configService;
+        }
+        TournamentApi.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/tournament/" + 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);
+                        }
+                    }
+                    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());
+                    }
+                    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]);
+                    }
+                    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');
+                        }
+                    }
+                    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');
+                        }
+                    }
+                    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.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;
+    }());
+
+    var TournamentJoinData = /** @class */ (function (_super) {
+        __extends(TournamentJoinData, _super);
+        function TournamentJoinData() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        Object.defineProperty(TournamentJoinData.prototype, "usersCount", {
+            get: function () {
+                return this.validUsersCount + this.invalidUsersCount;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(TournamentJoinData.prototype, "valid", {
+            get: function () {
+                return this.hasAccess && !this.inviteSent && !this.alreadyInTournament;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        TournamentJoinData.toFront = function (data) { };
+        TournamentJoinData.toBack = function (data) { };
+        __decorate([
+            ToFrontHook
+        ], TournamentJoinData, "toFront", null);
         __decorate([
             ToBackHook
-        ], TournamentStage, "toBack", null);
-        TournamentStage = __decorate([
+        ], TournamentJoinData, "toBack", null);
+        TournamentJoinData = __decorate([
             ModelInstance({
                 mappingFields: {
-                    id: 'id',
-                    name: 'name',
-                    date: 'date',
-                    tournament_id: 'tournamentId',
-                    status: 'status',
-                },
-                relation: {
-                    date: DateField,
-                    status: enumField(exports.TournamentStageStatuses)
+                    valid_users_count: 'validUsersCount',
+                    invalid_users_count: 'invalidUsersCount',
+                    has_access: 'hasAccess',
+                    invite_sent: 'inviteSent',
+                    already_in_tournament: 'alreadyInTournament'
                 }
             })
-        ], TournamentStage);
-        return TournamentStage;
+        ], TournamentJoinData);
+        return TournamentJoinData;
     }(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;
-    }
-
-    var PlayoffSettings = /** @class */ (function (_super) {
-        __extends(PlayoffSettings, _super);
-        function PlayoffSettings() {
+    var TournamentJoinTeam = /** @class */ (function (_super) {
+        __extends(TournamentJoinTeam, _super);
+        function TournamentJoinTeam() {
             return _super !== null && _super.apply(this, arguments) || this;
         }
-        PlayoffSettings.toFront = function (data) { };
-        PlayoffSettings.toBack = function (data) { };
+        TournamentJoinTeam.toFront = function (data) { };
+        TournamentJoinTeam.toBack = function (data) { };
         __decorate([
             ToFrontHook
-        ], PlayoffSettings, "toFront", null);
+        ], TournamentJoinTeam, "toFront", null);
         __decorate([
             ToBackHook
-        ], PlayoffSettings, "toBack", null);
-        PlayoffSettings = __decorate([
+        ], TournamentJoinTeam, "toBack", null);
+        TournamentJoinTeam = __decorate([
             ModelInstance({
                 mappingFields: {
-                    rounds: 'rounds',
-                    final_rounds: 'finalRounds',
-                    third_place_rounds: 'thirdPlaceRounds',
-                    teams_count: 'teamsCount'
+                    team: 'team',
+                    join_data: 'joinData'
+                },
+                relation: {
+                    team: Team,
+                    joinData: TournamentJoinData
                 }
             })
-        ], PlayoffSettings);
-        return PlayoffSettings;
+        ], TournamentJoinTeam);
+        return TournamentJoinTeam;
     }(BaseModel));
-    var Playoff = /** @class */ (function (_super) {
-        __extends(Playoff, _super);
-        function Playoff() {
-            var _this = _super !== null && _super.apply(this, arguments) || this;
-            _this.stages = [];
-            return _this;
+
+    var TournamentJoinApi = /** @class */ (function () {
+        function TournamentJoinApi(httpClient, configService) {
+            this.httpClient = httpClient;
+            this.configService = configService;
         }
-        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
+        TournamentJoinApi.prototype.getTeamsForJoin = 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_for_join/").pipe(operators.map(function (response) { return TournamentJoinTeam.toFront(response); })).toPromise()];
+                });
+            });
+        };
+        TournamentJoinApi.prototype.getTeamUsers = 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 + "/users/")
+                            .pipe(operators.map(function (data) { return TeamUser.toFront(data); })).toPromise()];
+                });
+            });
+        };
+        TournamentJoinApi.prototype.joinTournament = function (tournamentId, teamId, invites) {
+            return __awaiter(this, void 0, void 0, function () {
+                var body;
+                return __generator(this, function (_a) {
+                    body = {
+                        team: { id: teamId },
+                        user_invites: TournamentTeamUserInvite.toBack(invites)
                     };
+                    return [2 /*return*/, this.httpClient.post(this.configService.get('apiUrl') + "/api/v1/tournament/" + tournamentId + "/join/", body)
+                            .pipe(operators.map(function (data) { return TournamentInvite.toFront(data); }))
+                            .toPromise()];
+                });
+            });
+        };
+        TournamentJoinApi.ctorParameters = function () { return [
+            { type: http.HttpClient },
+            { type: ConfigService }
+        ]; };
+        TournamentJoinApi.ɵprov = core.ɵɵdefineInjectable({ factory: function TournamentJoinApi_Factory() { return new TournamentJoinApi(core.ɵɵinject(http.HttpClient), core.ɵɵinject(ConfigService)); }, token: TournamentJoinApi, providedIn: "root" });
+        TournamentJoinApi = __decorate([
+            core.Injectable({ providedIn: 'root' })
+        ], TournamentJoinApi);
+        return TournamentJoinApi;
+    }());
+
+    var TournamentStageApi = /** @class */ (function () {
+        function TournamentStageApi(httpClient, configService) {
+            this.httpClient = httpClient;
+            this.configService = configService;
+        }
+        TournamentStageApi.prototype.getById = function (id) {
+            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_stage/" + id + "/")
+                            .pipe(operators.map(function (result) { return TournamentStage.toFront(result); }))
+                            .toPromise()];
+                });
+            });
+        };
+        TournamentStageApi.prototype.getGroups = function (stageId) {
+            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_stage/" + stageId + "/groups/")
+                            .pipe(operators.map(function (result) { return TournamentGroup.toFront(result); }))
+                            .toPromise()];
+                });
+            });
+        };
+        TournamentStageApi.prototype.getPlayoffs = function (stageId) {
+            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_stage/" + stageId + "/playoff/")
+                            .pipe(operators.map(function (result) { return Playoff.toFront(result); }))
+                            .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));
+        TournamentStageApi.prototype.getTeams = function (stageId) {
+            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_stage/" + stageId + "/teams/")
+                            .pipe(operators.map(function (result) { return TournamentStageTeam.toFront(result); }))
+                            .toPromise()];
+                });
+            });
+        };
+        TournamentStageApi.ctorParameters = function () { return [
+            { type: http.HttpClient },
+            { type: ConfigService }
+        ]; };
+        TournamentStageApi.ɵprov = core.ɵɵdefineInjectable({ factory: function TournamentStageApi_Factory() { return new TournamentStageApi(core.ɵɵinject(http.HttpClient), core.ɵɵinject(ConfigService)); }, token: TournamentStageApi, providedIn: "root" });
+        TournamentStageApi = __decorate([
+            core.Injectable({ providedIn: 'root' })
+        ], TournamentStageApi);
+        return TournamentStageApi;
+    }());
 
-    var VolleyballStatistic = /** @class */ (function (_super) {
-        __extends(VolleyballStatistic, _super);
-        function VolleyballStatistic() {
+    var UserAccess = /** @class */ (function (_super) {
+        __extends(UserAccess, _super);
+        function UserAccess() {
             return _super !== null && _super.apply(this, arguments) || this;
         }
-        VolleyballStatistic.toFront = function (data) { };
-        VolleyballStatistic.toBack = function (data) { };
+        UserAccess.toFront = function (data) { };
+        UserAccess.toBack = function (data) { };
         __decorate([
             ToFrontHook
-        ], VolleyballStatistic, "toFront", null);
+        ], UserAccess, "toFront", null);
         __decorate([
             ToBackHook
-        ], VolleyballStatistic, "toBack", null);
-        VolleyballStatistic = __decorate([
+        ], UserAccess, "toBack", null);
+        UserAccess = __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,
+                    edit: 'edit',
+                    personal_data: 'personalData',
+                    teams: 'teams',
+                    statistic: 'statistic',
+                    games: 'games'
                 }
             })
-        ], VolleyballStatistic);
-        return VolleyballStatistic;
+        ], UserAccess);
+        return UserAccess;
     }(BaseModel));
 
-    var TournamentStageTeam = /** @class */ (function (_super) {
-        __extends(TournamentStageTeam, _super);
-        function TournamentStageTeam() {
+
+    (function (UserPermissionTypes) {
+        UserPermissionTypes[UserPermissionTypes["denied"] = 1] = "denied";
+        UserPermissionTypes[UserPermissionTypes["for_all"] = 2] = "for_all";
+        UserPermissionTypes[UserPermissionTypes["for_users"] = 3] = "for_users";
+        UserPermissionTypes[UserPermissionTypes["for_team"] = 4] = "for_team";
+    })(exports.UserPermissionTypes || (exports.UserPermissionTypes = {}));
+    var UserPermission = /** @class */ (function (_super) {
+        __extends(UserPermission, _super);
+        function UserPermission() {
             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) { };
+        UserPermission.toFront = function (data) { };
+        UserPermission.toBack = function (data) { };
         __decorate([
             ToFrontHook
-        ], TournamentStageTeam, "toFront", null);
+        ], UserPermission, "toFront", null);
         __decorate([
             ToBackHook
-        ], TournamentStageTeam, "toBack", null);
-        TournamentStageTeam = __decorate([
+        ], UserPermission, "toBack", null);
+        UserPermission = __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',
+                    personal_data: 'personalData',
+                    games: 'games',
+                    teams: 'teams',
+                    statistic: 'statistic'
                 },
                 relation: {
-                    tournamentTeam: TournamentTeam,
-                    group: TournamentGroup
+                    personalData: enumField(exports.UserPermissionTypes),
+                    games: enumField(exports.UserPermissionTypes),
+                    teams: enumField(exports.UserPermissionTypes),
+                    statistic: enumField(exports.UserPermissionTypes)
                 }
             })
-        ], TournamentStageTeam);
-        return TournamentStageTeam;
+        ], UserPermission);
+        return UserPermission;
     }(BaseModel));
 
-    var TournamentApi = /** @class */ (function () {
-        function TournamentApi(httpClient, configService) {
+    var UserApi = /** @class */ (function () {
+        function UserApi(httpClient, configService) {
             this.httpClient = httpClient;
             this.configService = configService;
         }
-        TournamentApi.prototype.getByAlias = function (alias) {
+        UserApi.prototype.getCurrentUser = function () {
             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/" + alias + "/")
-                            .pipe(operators.map(function (result) { return Tournament.toFront(result); }))
+                    return [2 /*return*/, this.httpClient
+                            .get(this.configService.get('apiUrl') + "/api/v1/user/current/")
+                            .pipe(operators.map(function (data) { return User.toFront(data); }))
                             .toPromise()];
                 });
             });
         };
-        TournamentApi.prototype.getNews = function (tournamentId) {
+        UserApi.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/" + tournamentId + "/news/")
-                            .pipe(operators.map(function (result) { return TournamentNews.toFront(result); }))
+                    return [2 /*return*/, this.httpClient
+                            .get(this.configService.get('apiUrl') + "/api/v1/user/" + userId + "/")
+                            .pipe(operators.map(function (data) { return User.toFront(data); }))
                             .toPromise()];
                 });
             });
         };
-        TournamentApi.prototype.getEvents = function (tournamentId, page, size, filters) {
+        UserApi.prototype.getAccess = function (userId) {
             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);
-                        }
-                    }
-                    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/user/" + (userId || 'current') + "/access/")
+                            .pipe(operators.map(function (data) { return UserAccess.toFront(data); }))
                             .toPromise()];
                 });
             });
         };
-        TournamentApi.prototype.getTournamentStages = function (tournamentId) {
+        UserApi.prototype.updateUser = function (userId, data) {
             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
+                            .patch(this.configService.get('apiUrl') + "/api/v1/user/" + userId + "/", User.toBack(data))
+                            .pipe(operators.map(function (result) { return User.toFront(result); }))
+                            .toPromise()];
                 });
             });
         };
-        TournamentApi.prototype.getPlayoff = function (tournamentId) {
+        UserApi.prototype.updateUserPhoto = function (file, filename) {
             return __awaiter(this, void 0, void 0, function () {
+                var formData;
                 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()];
+                    formData = new FormData();
+                    formData.append('file', file, filename);
+                    return [2 /*return*/, this.httpClient
+                            .post(this.configService.get('apiUrl') + "/api/v1/user/current/photo/", formData)
+                            .pipe(operators.map(function (data) { return File.toFront(data); }))
+                            .toPromise()];
                 });
             });
         };
-        TournamentApi.prototype.getPlayoffGames = function (playoffId) {
+        UserApi.prototype.changePassword = function (userId, oldPassword, password, passwordConfirm) {
             return __awaiter(this, void 0, void 0, function () {
+                var payload;
                 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()];
+                    payload = {
+                        old_password: oldPassword,
+                        password: password,
+                        password_confirm: passwordConfirm
+                    };
+                    return [2 /*return*/, this.httpClient
+                            .post(this.configService.get('apiUrl') + "/api/v1/user/" + userId + "/change_password/", payload)
+                            .toPromise()];
                 });
             });
         };
-        TournamentApi.prototype.getGamesStages = function (tournamentId) {
+        UserApi.prototype.changeEmail = function (userId, email, password) {
             return __awaiter(this, void 0, void 0, function () {
+                var payload;
                 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); }))
+                    payload = { email: email, password: password };
+                    return [2 /*return*/, this.httpClient
+                            .post(this.configService.get('apiUrl') + "/api/v1/user/" + userId + "/change_email/", payload)
                             .toPromise()];
                 });
             });
         };
-        TournamentApi.prototype.getGames = function (tournamentId, page, size, filters) {
-            if (filters === void 0) { filters = {}; }
+        UserApi.prototype.changeEmailConfirm = function (userId, email, password, token) {
             return __awaiter(this, void 0, void 0, function () {
-                var params;
+                var payload;
                 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]);
-                    }
-                    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()];
+                    payload = { email: email, password: password, token: token };
+                    return [2 /*return*/, this.httpClient
+                            .post(this.configService.get('apiUrl') + "/api/v1/user/" + userId + "/change_email_confirm/", payload)
+                            .toPromise()];
+                });
+            });
+        };
+        UserApi.prototype.getUserProfile = 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/user/" + userId + "/profile/")
+                            .pipe(operators.map(function (data) { return UserProfile.toFront(data); }))
+                            .toPromise()];
+                });
+            });
+        };
+        UserApi.prototype.getBasketballProfile = 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/user/" + userId + "/basketball_profile/")
+                            .pipe(operators.map(function (data) { return BasketballProfile.toFront(data); }))
+                            .toPromise()];
+                });
+            });
+        };
+        UserApi.prototype.getVolleyballProfile = 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/user/" + userId + "/volleyball_profile/")
+                            .pipe(operators.map(function (data) { return VolleyballProfile.toFront(data); }))
+                            .toPromise()];
+                });
+            });
+        };
+        UserApi.prototype.updateUserProfile = function (userProfile) {
+            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/user/" + userProfile.userId + "/profile/", UserProfile.toBack(userProfile))
+                            .pipe(operators.map(function (data) { return UserProfile.toFront(data); }))
+                            .toPromise()];
+                });
+            });
+        };
+        UserApi.prototype.updateUserBasketballProfile = function (basketballProfile) {
+            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/user/" + basketballProfile.userId + "/basketball_profile/", BasketballProfile.toBack(basketballProfile))
+                            .pipe(operators.map(function (data) { return BasketballProfile.toFront(data); }))
+                            .toPromise()];
+                });
+            });
+        };
+        UserApi.prototype.updateUserVolleyballProfile = function (volleyballProfile) {
+            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/user/" + volleyballProfile.userId + "/volleyball_profile/", VolleyballProfile.toBack(volleyballProfile))
+                            .pipe(operators.map(function (data) { return VolleyballProfile.toFront(data); }))
+                            .toPromise()];
+                });
+            });
+        };
+        UserApi.prototype.getUserPermissions = 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/user/" + (userId || 'current') + "/permission/")
+                            .pipe(operators.map(function (data) { return UserPermission.toFront(data); }))
+                            .toPromise()];
                 });
             });
         };
-        TournamentApi.prototype.getTeams = function (tournamentId) {
+        UserApi.prototype.updateUserPermission = function (data) {
             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
+                            .patch(this.configService.get('apiUrl') + "/api/v1/user/current/permission/", UserPermission.toBack(data))
+                            .pipe(operators.map(function (result) { return UserPermission.toFront(result); }))
                             .toPromise()];
                 });
             });
         };
-        TournamentApi.prototype.getStageTeams = function (tournamentId) {
+        UserApi.prototype.getTeams = 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/" + tournamentId + "/stage_teams/")
-                            .pipe(operators.map(function (result) { return TournamentStageTeam.toFront(result); }))
+                    return [2 /*return*/, this.httpClient
+                            .get(this.configService.get('apiUrl') + "/api/v1/user/" + userId + "/teams/")
+                            .pipe(operators.map(function (data) { return Team.toFront(data); }))
                             .toPromise()];
                 });
             });
         };
-        TournamentApi.prototype.getTeamById = function (tournamentTeamId) {
+        UserApi.prototype.getInvites = function () {
             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
+                            .get(this.configService.get('apiUrl') + "/api/v1/user/current/invites/")
+                            .pipe(operators.map(function (data) { return TeamInvite.toFront(data); }))
                             .toPromise()];
                 });
             });
         };
-        TournamentApi.prototype.getUserById = function (userId) {
+        UserApi.prototype.acceptInvite = function (inviteId) {
             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/user/current/invites/" + inviteId + "/accept/", {})
+                            .pipe(operators.map(function (data) { return TeamInvite.toFront(data); }))
                             .toPromise()];
                 });
             });
         };
-        TournamentApi.prototype.getUserGames = function (tournamentUserId) {
+        UserApi.prototype.declineInvite = function (inviteId) {
             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
+                            .post(this.configService.get('apiUrl') + "/api/v1/user/current/invites/" + inviteId + "/decline/", {})
+                            .pipe(operators.map(function (data) { return TeamInvite.toFront(data); }))
                             .toPromise()];
                 });
             });
         };
-        TournamentApi.prototype.getBasketballStatistic = function (filters) {
+        UserApi.prototype.getStatistics = function (userId) {
             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
+                            .get(this.configService.get('apiUrl') + "/api/v1/user/" + userId + "/statistics/")
+                            .pipe(operators.map(function (data) { return BasketballStatistic.toFront(data); }))
+                            .toPromise()];
                 });
             });
         };
-        TournamentApi.prototype.getVolleyballStatistic = function (filters) {
+        UserApi.prototype.getStreetballStatistics = function (userId) {
             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
+                            .get(this.configService.get('apiUrl') + "/api/v1/user/" + userId + "/streetball_statistics/")
+                            .pipe(operators.map(function (data) { return BasketballStatistic.toFront(data); }))
+                            .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;
-    }());
-
-    var TournamentJoinData = /** @class */ (function (_super) {
-        __extends(TournamentJoinData, _super);
-        function TournamentJoinData() {
-            return _super !== null && _super.apply(this, arguments) || this;
-        }
-        Object.defineProperty(TournamentJoinData.prototype, "usersCount", {
-            get: function () {
-                return this.validUsersCount + this.invalidUsersCount;
-            },
-            enumerable: true,
-            configurable: true
-        });
-        Object.defineProperty(TournamentJoinData.prototype, "valid", {
-            get: function () {
-                return this.hasAccess && !this.inviteSent && !this.alreadyInTournament;
-            },
-            enumerable: true,
-            configurable: true
-        });
-        TournamentJoinData.toFront = function (data) { };
-        TournamentJoinData.toBack = function (data) { };
-        __decorate([
-            ToFrontHook
-        ], TournamentJoinData, "toFront", null);
-        __decorate([
-            ToBackHook
-        ], TournamentJoinData, "toBack", null);
-        TournamentJoinData = __decorate([
-            ModelInstance({
-                mappingFields: {
-                    valid_users_count: 'validUsersCount',
-                    invalid_users_count: 'invalidUsersCount',
-                    has_access: 'hasAccess',
-                    invite_sent: 'inviteSent',
-                    already_in_tournament: 'alreadyInTournament'
-                }
-            })
-        ], TournamentJoinData);
-        return TournamentJoinData;
-    }(BaseModel));
-    var TournamentJoinTeam = /** @class */ (function (_super) {
-        __extends(TournamentJoinTeam, _super);
-        function TournamentJoinTeam() {
-            return _super !== null && _super.apply(this, arguments) || this;
-        }
-        TournamentJoinTeam.toFront = function (data) { };
-        TournamentJoinTeam.toBack = function (data) { };
-        __decorate([
-            ToFrontHook
-        ], TournamentJoinTeam, "toFront", null);
-        __decorate([
-            ToBackHook
-        ], TournamentJoinTeam, "toBack", null);
-        TournamentJoinTeam = __decorate([
-            ModelInstance({
-                mappingFields: {
-                    team: 'team',
-                    join_data: 'joinData'
-                },
-                relation: {
-                    team: Team,
-                    joinData: TournamentJoinData
-                }
-            })
-        ], TournamentJoinTeam);
-        return TournamentJoinTeam;
-    }(BaseModel));
-
-    var TournamentJoinApi = /** @class */ (function () {
-        function TournamentJoinApi(httpClient, configService) {
-            this.httpClient = httpClient;
-            this.configService = configService;
-        }
-        TournamentJoinApi.prototype.getTeamsForJoin = function (tournamentId) {
+        UserApi.prototype.getVolleyballStatistic = 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/" + tournamentId + "/teams_for_join/").pipe(operators.map(function (response) { return TournamentJoinTeam.toFront(response); })).toPromise()];
+                    return [2 /*return*/, this.httpClient
+                            .get(this.configService.get('apiUrl') + "/api/v1/user/" + userId + "/volleyball_statistics/")
+                            .pipe(operators.map(function (data) { return VolleyballStatistic.toFront(data); }))
+                            .toPromise()];
                 });
             });
         };
-        TournamentJoinApi.prototype.getTeamUsers = function (teamId) {
+        UserApi.prototype.getGames = 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/team/" + teamId + "/users/")
-                            .pipe(operators.map(function (data) { return TeamUser.toFront(data); })).toPromise()];
+                            .get(this.configService.get('apiUrl') + "/api/v1/user/" + userId + "/games/")
+                            .pipe(operators.map(function (data) { return Game.toFront(data); }))
+                            .toPromise()];
                 });
             });
         };
-        TournamentJoinApi.prototype.joinTournament = function (tournamentId, teamId, invites) {
+        UserApi.prototype.getGameInvites = function () {
             return __awaiter(this, void 0, void 0, function () {
-                var body;
                 return __generator(this, function (_a) {
-                    body = {
-                        team: { id: teamId },
-                        user_invites: TournamentTeamUserInvite.toBack(invites)
-                    };
-                    return [2 /*return*/, this.httpClient.post(this.configService.get('apiUrl') + "/api/v1/tournament/" + tournamentId + "/join/", body)
-                            .pipe(operators.map(function (data) { return TournamentInvite.toFront(data); }))
+                    return [2 /*return*/, this.httpClient
+                            .get(this.configService.get('apiUrl') + "/api/v1/user/current/game_invites/")
+                            .pipe(operators.map(function (data) { return GameInvite.toFront(data); }))
                             .toPromise()];
                 });
             });
         };
-        TournamentJoinApi.ctorParameters = function () { return [
-            { type: http.HttpClient },
-            { type: ConfigService }
-        ]; };
-        TournamentJoinApi.ɵprov = core.ɵɵdefineInjectable({ factory: function TournamentJoinApi_Factory() { return new TournamentJoinApi(core.ɵɵinject(http.HttpClient), core.ɵɵinject(ConfigService)); }, token: TournamentJoinApi, providedIn: "root" });
-        TournamentJoinApi = __decorate([
-            core.Injectable({ providedIn: 'root' })
-        ], TournamentJoinApi);
-        return TournamentJoinApi;
-    }());
-
-    var TournamentStageApi = /** @class */ (function () {
-        function TournamentStageApi(httpClient, configService) {
-            this.httpClient = httpClient;
-            this.configService = configService;
-        }
-        TournamentStageApi.prototype.getById = function (id) {
+        UserApi.prototype.acceptGameInvite = function (inviteId) {
             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_stage/" + id + "/")
-                            .pipe(operators.map(function (result) { return TournamentStage.toFront(result); }))
+                    return [2 /*return*/, this.httpClient
+                            .post(this.configService.get('apiUrl') + "/api/v1/user/current/game_invites/" + inviteId + "/accept/", {})
+                            .pipe(operators.map(function (data) { return GameInvite.toFront(data); }))
                             .toPromise()];
                 });
             });
         };
-        TournamentStageApi.prototype.getGroups = function (stageId) {
+        UserApi.prototype.declineGameInvite = function (inviteId) {
             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_stage/" + stageId + "/groups/")
-                            .pipe(operators.map(function (result) { return TournamentGroup.toFront(result); }))
+                    return [2 /*return*/, this.httpClient
+                            .post(this.configService.get('apiUrl') + "/api/v1/user/current/game_invites/" + inviteId + "/decline/", {})
+                            .pipe(operators.map(function (data) { return GameInvite.toFront(data); }))
                             .toPromise()];
                 });
             });
         };
-        TournamentStageApi.prototype.getPlayoffs = function (stageId) {
+        UserApi.prototype.searchUsers = function (query) {
             return __awaiter(this, void 0, void 0, function () {
+                var params;
                 return __generator(this, function (_a) {
-                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament_stage/" + stageId + "/playoff/")
-                            .pipe(operators.map(function (result) { return Playoff.toFront(result); }))
+                    params = (new http.HttpParams()).set('search', query);
+                    return [2 /*return*/, this.httpClient
+                            .get(this.configService.get('apiUrl') + "/api/v1/user/", { params: params })
+                            .pipe(operators.map(function (data) { return User.toFront(data); }))
                             .toPromise()];
                 });
             });
         };
-        TournamentStageApi.prototype.getTeams = function (stageId) {
+        UserApi.prototype.setWizardShowed = function (wizard) {
             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_stage/" + stageId + "/teams/")
-                            .pipe(operators.map(function (result) { return TournamentStageTeam.toFront(result); }))
+                    return [2 /*return*/, this.httpClient
+                            .put(this.configService.get('apiUrl') + "/api/v1/user/current/wizards/", { wizard: wizard })
+                            .pipe(operators.map(function (data) { return User.toFront(data); }))
                             .toPromise()];
                 });
             });
         };
-        TournamentStageApi.ctorParameters = function () { return [
+        UserApi.prototype.getTeamEvents = 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/user/current/team_events/")
+                            .pipe(operators.map(function (data) { return TeamEvent.toFront(data); }))
+                            .toPromise()];
+                });
+            });
+        };
+        UserApi.ctorParameters = function () { return [
             { type: http.HttpClient },
             { type: ConfigService }
         ]; };
-        TournamentStageApi.ɵprov = core.ɵɵdefineInjectable({ factory: function TournamentStageApi_Factory() { return new TournamentStageApi(core.ɵɵinject(http.HttpClient), core.ɵɵinject(ConfigService)); }, token: TournamentStageApi, providedIn: "root" });
-        TournamentStageApi = __decorate([
+        UserApi.ɵprov = core.ɵɵdefineInjectable({ factory: function UserApi_Factory() { return new UserApi(core.ɵɵinject(http.HttpClient), core.ɵɵinject(ConfigService)); }, token: UserApi, providedIn: "root" });
+        UserApi = __decorate([
             core.Injectable({ providedIn: 'root' })
-        ], TournamentStageApi);
-        return TournamentStageApi;
+        ], UserApi);
+        return UserApi;
     }());
 
     var VolleyballGameTeamStatistic = /** @class */ (function (_super) {
@@ -4233,33 +5501,6 @@
         _a$5[exports.VolleyballGameLogType.timeout] = 'Таймаут',
         _a$5);
 
-    var TeamInviteExternal = /** @class */ (function (_super) {
-        __extends(TeamInviteExternal, _super);
-        function TeamInviteExternal() {
-            return _super !== null && _super.apply(this, arguments) || this;
-        }
-        TeamInviteExternal.toFront = function (data) { };
-        TeamInviteExternal.toBack = function (data) { };
-        __decorate([
-            ToFrontHook
-        ], TeamInviteExternal, "toFront", null);
-        __decorate([
-            ToBackHook
-        ], TeamInviteExternal, "toBack", null);
-        TeamInviteExternal = __decorate([
-            ModelInstance({
-                mappingFields: {
-                    id: 'id',
-                    team_id: 'teamId',
-                    email: 'email',
-                    first_name: 'firstName',
-                    last_name: 'lastName',
-                },
-            })
-        ], TeamInviteExternal);
-        return TeamInviteExternal;
-    }(BaseModel));
-
     var CentrifugoService = /** @class */ (function () {
         function CentrifugoService(httpClient, configService) {
             this.httpClient = httpClient;
@@ -4335,7 +5576,6 @@
             this.subscriptions = {};
         };
         CentrifugoService.prototype.initializeEngine = function (config) {
-            console.log(config);
             this.centrifuge = new Centrifuge(config);
         };
         CentrifugoService.prototype.addEngineSubscription = function (channel) {
@@ -4677,7 +5917,10 @@
     exports.DateField = DateField;
     exports.DateTimeField = DateTimeField;
     exports.FAULT_LOG_TYPES = FAULT_LOG_TYPES;
+    exports.Feedback = Feedback;
+    exports.FeedbackApi = FeedbackApi;
     exports.File = File;
+    exports.FileApi = FileApi;
     exports.Game = Game;
     exports.GameBasketballPositionLocalization = GameBasketballPositionLocalization;
     exports.GameBasketballPositionShortLocalization = GameBasketballPositionShortLocalization;
@@ -4692,6 +5935,8 @@
     exports.League = League;
     exports.LeagueApi = LeagueApi;
     exports.LeagueCourt = LeagueCourt;
+    exports.LeagueNews = LeagueNews;
+    exports.LeagueNewsApi = LeagueNewsApi;
     exports.LocalStorageEngine = LocalStorageEngine;
     exports.MediaApi = MediaApi;
     exports.MediaItem = MediaItem;
@@ -4715,11 +5960,15 @@
     exports.StorageEngineField = StorageEngineField;
     exports.Store = Store;
     exports.Team = Team;
+    exports.TeamAccess = TeamAccess;
+    exports.TeamApi = TeamApi;
     exports.TeamEvent = TeamEvent;
+    exports.TeamEventApi = TeamEventApi;
     exports.TeamEventInvite = TeamEventInvite;
     exports.TeamEventTypeLocalization = TeamEventTypeLocalization;
     exports.TeamInvite = TeamInvite;
     exports.TeamInviteExternal = TeamInviteExternal;
+    exports.TeamPermission = TeamPermission;
     exports.TeamUser = TeamUser;
     exports.TeamUserRoleLocalization = TeamUserRoleLocalization;
     exports.ToBackHook = ToBackHook;
@@ -4744,6 +5993,9 @@
     exports.TournamentTeamWinner = TournamentTeamWinner;
     exports.UntilDestroy = UntilDestroy;
     exports.User = User;
+    exports.UserAccess = UserAccess;
+    exports.UserApi = UserApi;
+    exports.UserPermission = UserPermission;
     exports.UserProfile = UserProfile;
     exports.VolleyballGameApi = VolleyballGameApi;
     exports.VolleyballGameConfig = VolleyballGameConfig;