@mtgame/core 0.0.3 → 0.0.5

package/fesm5/mtgame-core.js

@@ -762,6 +762,11 @@ var BasketballStatisticTypes;
     BasketballStatisticTypes[BasketballStatisticTypes["light"] = 2] = "light";
     BasketballStatisticTypes[BasketballStatisticTypes["extended"] = 3] = "extended";
 })(BasketballStatisticTypes || (BasketballStatisticTypes = {}));
+var GameTimeTypes;
+(function (GameTimeTypes) {
+    GameTimeTypes[GameTimeTypes["clean"] = 1] = "clean";
+    GameTimeTypes[GameTimeTypes["dirty"] = 2] = "dirty";
+})(GameTimeTypes || (GameTimeTypes = {}));
 var TournamentSettings = /** @class */ (function (_super) {
     __extends(TournamentSettings, _super);
     function TournamentSettings() {
@@ -802,11 +807,14 @@ var TournamentSettings = /** @class */ (function (_super) {
                 recruitment_is_open: 'recruitmentIsOpen',
                 transfer_is_open: 'transferIsOpen',
                 basketball_statistic_type: 'basketballStatisticType',
+                shot_clock_enabled: 'shotClockEnabled',
+                game_time_type: 'gameTimeType',
             },
             relation: {
                 type: enumField(TournamentTypes),
                 gender: enumField(TournamentGender),
                 basketballStatisticType: enumField(BasketballStatisticTypes),
+                gameTimeType: enumField(GameTimeTypes),
             }
         })
     ], TournamentSettings);
@@ -937,10 +945,13 @@ var BasketballGameConfig = /** @class */ (function (_super) {
                 overtime_timeout_count: 'overtimeTimeoutCount',
                 timeout_time: 'timeoutTime',
                 statistic_type: 'statisticType',
+                shot_clock_enabled: 'shotClockEnabled',
+                game_time_type: 'gameTimeType',
             },
             relation: {
                 overtimeType: enumField(OvertimeTypes),
-                statisticType: enumField(BasketballStatisticTypes)
+                statisticType: enumField(BasketballStatisticTypes),
+                gameTimeType: enumField(GameTimeTypes),
             }
         })
     ], BasketballGameConfig);
@@ -1966,10 +1977,160 @@ var BasketballGameApi = /** @class */ (function () {
     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(map(function (response) { return Feedback.toFront(response); }))
+                        .toPromise()];
+            });
+        });
+    };
+    FeedbackApi.ctorParameters = function () { return [
+        { type: HttpClient },
+        { type: ConfigService }
+    ]; };
+    FeedbackApi.ɵprov = ɵɵdefineInjectable({ factory: function FeedbackApi_Factory() { return new FeedbackApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: FeedbackApi, providedIn: "root" });
+    FeedbackApi = __decorate([
+        Injectable({ providedIn: 'root' })
+    ], FeedbackApi);
+    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(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: HttpClient },
+        { type: ConfigService }
+    ]; };
+    FileApi.ɵprov = ɵɵdefineInjectable({ factory: function FileApi_Factory() { return new FileApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: FileApi, providedIn: "root" });
+    FileApi = __decorate([
+        Injectable({ providedIn: 'root' })
+    ], FileApi);
+    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));
+
 var TournamentEventTypes;
 (function (TournamentEventTypes) {
     TournamentEventTypes[TournamentEventTypes["game_closed"] = 1] = "game_closed";
     TournamentEventTypes[TournamentEventTypes["media_added"] = 2] = "media_added";
+    TournamentEventTypes[TournamentEventTypes["news"] = 3] = "news";
 })(TournamentEventTypes || (TournamentEventTypes = {}));
 var TournamentEvent = /** @class */ (function (_super) {
     __extends(TournamentEvent, _super);
@@ -1989,13 +2150,17 @@ var TournamentEvent = /** @class */ (function (_super) {
             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(TournamentEventTypes)
             }
@@ -2062,6 +2227,64 @@ var LeagueApi = /** @class */ (function () {
     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(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(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(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(map(function (response) { return ({
+                        total: +response.headers.get('X-Page-Count'),
+                        data: LeagueNews.toFront(response.body)
+                    }); }))
+                        .toPromise()];
+            });
+        });
+    };
+    LeagueNewsApi.ctorParameters = function () { return [
+        { type: HttpClient },
+        { type: ConfigService }
+    ]; };
+    LeagueNewsApi.ɵprov = ɵɵdefineInjectable({ factory: function LeagueNewsApi_Factory() { return new LeagueNewsApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: LeagueNewsApi, providedIn: "root" });
+    LeagueNewsApi = __decorate([
+        Injectable({ providedIn: 'root' })
+    ], LeagueNewsApi);
+    return LeagueNewsApi;
+}());
+
 var MediaApi = /** @class */ (function () {
     function MediaApi(httpClient, configService) {
         this.httpClient = httpClient;
@@ -2895,733 +3118,1787 @@ var ReferenceApi = /** @class */ (function () {
     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));
+
+var TeamPermissionTypes;
+(function (TeamPermissionTypes) {
+    TeamPermissionTypes[TeamPermissionTypes["for_all"] = 1] = "for_all";
+    TeamPermissionTypes[TeamPermissionTypes["for_users"] = 2] = "for_users";
+    TeamPermissionTypes[TeamPermissionTypes["for_team"] = 3] = "for_team";
+})(TeamPermissionTypes || (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(TeamPermissionTypes),
+                games: enumField(TeamPermissionTypes),
+                statistic: enumField(TeamPermissionTypes),
+                polls: enumField(TeamPermissionTypes),
+                events: enumField(TeamPermissionTypes)
             }
         })
-    ], GameTimelineStages);
-    return GameTimelineStages;
+    ], TeamPermission);
+    return TeamPermission;
 }(BaseModel));
 
-var TournamentStageStatuses;
-(function (TournamentStageStatuses) {
-    TournamentStageStatuses[TournamentStageStatuses["open"] = 0] = "open";
-    TournamentStageStatuses[TournamentStageStatuses["in_progress"] = 1] = "in_progress";
-    TournamentStageStatuses[TournamentStageStatuses["closed"] = 2] = "closed";
-})(TournamentStageStatuses || (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;
     }
-    TournamentStage.toFront = function (data) { };
+    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(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 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(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(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(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(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(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(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(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 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(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: TeamUserRole[role] })
+                        .pipe(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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 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(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(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(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(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(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(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: HttpClient },
+        { type: ConfigService }
+    ]; };
+    TeamApi.ɵprov = ɵɵdefineInjectable({ factory: function TeamApi_Factory() { return new TeamApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: TeamApi, providedIn: "root" });
+    TeamApi = __decorate([
+        Injectable({ providedIn: 'root' })
+    ], TeamApi);
+    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(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(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(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(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(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(map(function (data) { return TeamEventInvite.toFront(data); }))
+                        .toPromise()];
+            });
+        });
+    };
+    TeamEventApi.ctorParameters = function () { return [
+        { type: HttpClient },
+        { type: ConfigService }
+    ]; };
+    TeamEventApi.ɵprov = ɵɵdefineInjectable({ factory: function TeamEventApi_Factory() { return new TeamEventApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: TeamEventApi, providedIn: "root" });
+    TeamEventApi = __decorate([
+        Injectable({ providedIn: 'root' })
+    ], TeamEventApi);
+    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));
+
+var TournamentStageStatuses;
+(function (TournamentStageStatuses) {
+    TournamentStageStatuses[TournamentStageStatuses["open"] = 0] = "open";
+    TournamentStageStatuses[TournamentStageStatuses["in_progress"] = 1] = "in_progress";
+    TournamentStageStatuses[TournamentStageStatuses["closed"] = 2] = "closed";
+})(TournamentStageStatuses || (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(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(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(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 HttpParams().set('page', page.toString())
+                    .set('size', size.toString());
+                if (filters) {
+                    if (filters.event) {
+                        params = params.set('event', 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(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(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(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(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(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 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', GameStatuses[filters.status]);
+                }
+                return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament/" + tournamentId + "/games/", { params: params, observe: 'response' })
+                        .pipe(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(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(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(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(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(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 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(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 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(map(function (result) { return VolleyballStatistic.toFront(result); })).toPromise()];
+            });
+        });
+    };
+    TournamentApi.ctorParameters = function () { return [
+        { type: HttpClient },
+        { type: ConfigService }
+    ]; };
+    TournamentApi.ɵprov = ɵɵdefineInjectable({ factory: function TournamentApi_Factory() { return new TournamentApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: TournamentApi, providedIn: "root" });
+    TournamentApi = __decorate([
+        Injectable({ providedIn: 'root' })
+    ], TournamentApi);
+    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(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(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(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(map(function (data) { return TournamentInvite.toFront(data); }))
+                        .toPromise()];
+            });
+        });
+    };
+    TournamentJoinApi.ctorParameters = function () { return [
+        { type: HttpClient },
+        { type: ConfigService }
+    ]; };
+    TournamentJoinApi.ɵprov = ɵɵdefineInjectable({ factory: function TournamentJoinApi_Factory() { return new TournamentJoinApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: TournamentJoinApi, providedIn: "root" });
+    TournamentJoinApi = __decorate([
+        Injectable({ providedIn: 'root' })
+    ], TournamentJoinApi);
+    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(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(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(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(map(function (result) { return TournamentStageTeam.toFront(result); }))
+                        .toPromise()];
+            });
+        });
+    };
+    TournamentStageApi.ctorParameters = function () { return [
+        { type: HttpClient },
+        { type: ConfigService }
+    ]; };
+    TournamentStageApi.ɵprov = ɵɵdefineInjectable({ factory: function TournamentStageApi_Factory() { return new TournamentStageApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: TournamentStageApi, providedIn: "root" });
+    TournamentStageApi = __decorate([
+        Injectable({ providedIn: 'root' })
+    ], TournamentStageApi);
+    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() {
+var UserPermissionTypes;
+(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";
+})(UserPermissionTypes || (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(UserPermissionTypes),
+                games: enumField(UserPermissionTypes),
+                teams: enumField(UserPermissionTypes),
+                statistic: enumField(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(map(function (result) { return Tournament.toFront(result); }))
+                return [2 /*return*/, this.httpClient
+                        .get(this.configService.get('apiUrl') + "/api/v1/user/current/")
+                        .pipe(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(map(function (result) { return TournamentNews.toFront(result); }))
+                return [2 /*return*/, this.httpClient
+                        .get(this.configService.get('apiUrl') + "/api/v1/user/" + userId + "/")
+                        .pipe(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 HttpParams().set('page', page.toString())
-                    .set('size', size.toString());
-                if (filters) {
-                    if (filters.event) {
-                        params = params.set('event', 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(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(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(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(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(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(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(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(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 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', GameStatuses[filters.status]);
-                }
-                return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament/" + tournamentId + "/games/", { params: params, observe: 'response' })
-                        .pipe(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(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(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(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(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(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(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(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(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(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(map(function (result) { return TournamentStageTeam.toFront(result); }))
+                return [2 /*return*/, this.httpClient
+                        .get(this.configService.get('apiUrl') + "/api/v1/user/" + userId + "/teams/")
+                        .pipe(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(map(function (result) { return TournamentTeam.toFront(result); }))
+                return [2 /*return*/, this.httpClient
+                        .get(this.configService.get('apiUrl') + "/api/v1/user/current/invites/")
+                        .pipe(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(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(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(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(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 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(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(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 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(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(map(function (data) { return BasketballStatistic.toFront(data); }))
+                        .toPromise()];
             });
         });
     };
-    TournamentApi.ctorParameters = function () { return [
-        { type: HttpClient },
-        { type: ConfigService }
-    ]; };
-    TournamentApi.ɵprov = ɵɵdefineInjectable({ factory: function TournamentApi_Factory() { return new TournamentApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: TournamentApi, providedIn: "root" });
-    TournamentApi = __decorate([
-        Injectable({ providedIn: 'root' })
-    ], TournamentApi);
-    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(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(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(map(function (data) { return TeamUser.toFront(data); })).toPromise()];
+                        .get(this.configService.get('apiUrl') + "/api/v1/user/" + userId + "/games/")
+                        .pipe(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(map(function (data) { return TournamentInvite.toFront(data); }))
+                return [2 /*return*/, this.httpClient
+                        .get(this.configService.get('apiUrl') + "/api/v1/user/current/game_invites/")
+                        .pipe(map(function (data) { return GameInvite.toFront(data); }))
                         .toPromise()];
             });
         });
     };
-    TournamentJoinApi.ctorParameters = function () { return [
-        { type: HttpClient },
-        { type: ConfigService }
-    ]; };
-    TournamentJoinApi.ɵprov = ɵɵdefineInjectable({ factory: function TournamentJoinApi_Factory() { return new TournamentJoinApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: TournamentJoinApi, providedIn: "root" });
-    TournamentJoinApi = __decorate([
-        Injectable({ providedIn: 'root' })
-    ], TournamentJoinApi);
-    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(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(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(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(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(map(function (result) { return Playoff.toFront(result); }))
+                params = (new HttpParams()).set('search', query);
+                return [2 /*return*/, this.httpClient
+                        .get(this.configService.get('apiUrl') + "/api/v1/user/", { params: params })
+                        .pipe(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(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(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(map(function (data) { return TeamEvent.toFront(data); }))
+                        .toPromise()];
+            });
+        });
+    };
+    UserApi.ctorParameters = function () { return [
         { type: HttpClient },
         { type: ConfigService }
     ]; };
-    TournamentStageApi.ɵprov = ɵɵdefineInjectable({ factory: function TournamentStageApi_Factory() { return new TournamentStageApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: TournamentStageApi, providedIn: "root" });
-    TournamentStageApi = __decorate([
+    UserApi.ɵprov = ɵɵdefineInjectable({ factory: function UserApi_Factory() { return new UserApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: UserApi, providedIn: "root" });
+    UserApi = __decorate([
         Injectable({ providedIn: 'root' })
-    ], TournamentStageApi);
-    return TournamentStageApi;
+    ], UserApi);
+    return UserApi;
 }());
 
 var VolleyballGameTeamStatistic = /** @class */ (function (_super) {
@@ -4020,33 +5297,6 @@ var VolleyballGameLogTypeLocalization = (_a$5 = {},
     _a$5[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;
@@ -4450,5 +5700,5 @@ var HttpCookieInterceptor = /** @class */ (function () {
  * Generated bundle index. Do not edit.
  */
 
-export { BaseModel, BaseService, BasketballGameApi, BasketballGameConfig, BasketballGameLog, BasketballGameLogTypeLocalization, BasketballGameLogTypes, BasketballGameStatistic, BasketballGameTeamStatistic, BasketballProfile, BasketballStatistic, BasketballStatisticTypes, CONFIG_DATA, CentrifugoService, City, ConfigService, DateField, DateTimeField, FAULT_LOG_TYPES, File, FileEngine, Game, GameBasketballPosition, GameBasketballPositionLocalization, GameBasketballPositionShortLocalization, GameInvite, GameInviteStatus, GameResultTypes, GameStatuses, GameTimelineStageItem, GameTimelineStages, GameUser, GameVolleyballPosition, GameVolleyballPositionLocalization, GameVolleyballPositionShortLocalization, GameVolleyballPositionShortRuLocalization, HttpCookieInterceptor, League, LeagueApi, LeagueCourt, LocalStorageEngine, MediaApi, MediaItem, ModelInstance, Notification, NotificationAllowTypes, NotificationApi, NotificationBaseApi, NotificationServiceEnum, NotificationSettings, NotificationType, OrgNotificationApi, Organization, OvertimeTypeLocalization, OvertimeTypes, Playoff, PlayoffSettings, Poll, PollAnswer, PollStatuses, PollVariant, ReferenceApi, SCORE_LOG_TYPES, Sport, SportTypes, StorageEngine, StorageEngineField, Store, Team, TeamEvent, TeamEventInvite, TeamEventInviteStatuses, TeamEventTypeLocalization, TeamEventTypes, TeamInvite, TeamInviteExternal, TeamUser, TeamUserRole, TeamUserRoleLocalization, ToBackHook, ToFrontHook, Tournament, TournamentApi, TournamentDisqualification, TournamentEvent, TournamentEventTypes, TournamentGender, TournamentGroup, TournamentInvite, TournamentJoinApi, TournamentJoinData, TournamentJoinTeam, TournamentNews, TournamentSettings, TournamentStage, TournamentStageApi, TournamentStageStatuses, TournamentStageTeam, TournamentStatuses, TournamentTeam, TournamentTeamUser, TournamentTeamUserInvite, TournamentTeamWinner, TournamentTypes, UntilDestroy, User, UserGender, UserProfile, VolleyballGameApi, VolleyballGameConfig, VolleyballGameLog, VolleyballGameLogType, VolleyballGameLogTypeLocalization, VolleyballGameStatistic, VolleyballGameTeamStatistic, VolleyballGameTypes, VolleyballProfile, VolleyballStatistic, VolleyballWorkHand, VolleyballWorkHandLocalization, WorkHand, WorkHandLocalization, addItemInArray, changeFavicons, componentDestroyed, deleteItemFromArray, enumField, fileSizeValidator, generateArray, getArrayChunks, getCookie, getEnumOptions, getIconsData, handleError, isTouchDevice, listField, markFormGroupTouched, minLengthArrayValidator, patchItemInArray, updateItemInArray, updateItemsInArray, validateDate, validateEmail, validatePhone, validateUrl };
+export { BaseModel, BaseService, BasketballGameApi, BasketballGameConfig, BasketballGameLog, BasketballGameLogTypeLocalization, BasketballGameLogTypes, BasketballGameStatistic, BasketballGameTeamStatistic, BasketballProfile, BasketballStatistic, BasketballStatisticTypes, CONFIG_DATA, CentrifugoService, City, ConfigService, DateField, DateTimeField, FAULT_LOG_TYPES, Feedback, FeedbackApi, File, FileApi, FileEngine, Game, GameBasketballPosition, GameBasketballPositionLocalization, GameBasketballPositionShortLocalization, GameInvite, GameInviteStatus, GameResultTypes, GameStatuses, GameTimeTypes, GameTimelineStageItem, GameTimelineStages, GameUser, GameVolleyballPosition, GameVolleyballPositionLocalization, GameVolleyballPositionShortLocalization, GameVolleyballPositionShortRuLocalization, HttpCookieInterceptor, League, LeagueApi, LeagueCourt, LeagueNews, LeagueNewsApi, LocalStorageEngine, MediaApi, MediaItem, ModelInstance, Notification, NotificationAllowTypes, NotificationApi, NotificationBaseApi, NotificationServiceEnum, NotificationSettings, NotificationType, OrgNotificationApi, Organization, OvertimeTypeLocalization, OvertimeTypes, Playoff, PlayoffSettings, Poll, PollAnswer, PollStatuses, PollVariant, ReferenceApi, SCORE_LOG_TYPES, Sport, SportTypes, StorageEngine, StorageEngineField, Store, Team, TeamAccess, TeamApi, TeamEvent, TeamEventApi, TeamEventInvite, TeamEventInviteStatuses, TeamEventTypeLocalization, TeamEventTypes, TeamInvite, TeamInviteExternal, TeamPermission, TeamPermissionTypes, TeamUser, TeamUserRole, TeamUserRoleLocalization, ToBackHook, ToFrontHook, Tournament, TournamentApi, TournamentDisqualification, TournamentEvent, TournamentEventTypes, TournamentGender, TournamentGroup, TournamentInvite, TournamentJoinApi, TournamentJoinData, TournamentJoinTeam, TournamentNews, TournamentSettings, TournamentStage, TournamentStageApi, TournamentStageStatuses, TournamentStageTeam, TournamentStatuses, TournamentTeam, TournamentTeamUser, TournamentTeamUserInvite, TournamentTeamWinner, TournamentTypes, UntilDestroy, User, UserAccess, UserApi, UserGender, UserPermission, UserPermissionTypes, UserProfile, VolleyballGameApi, VolleyballGameConfig, VolleyballGameLog, VolleyballGameLogType, VolleyballGameLogTypeLocalization, VolleyballGameStatistic, VolleyballGameTeamStatistic, VolleyballGameTypes, VolleyballProfile, VolleyballStatistic, VolleyballWorkHand, VolleyballWorkHandLocalization, WorkHand, WorkHandLocalization, addItemInArray, changeFavicons, componentDestroyed, deleteItemFromArray, enumField, fileSizeValidator, generateArray, getArrayChunks, getCookie, getEnumOptions, getIconsData, handleError, isTouchDevice, listField, markFormGroupTouched, minLengthArrayValidator, patchItemInArray, updateItemInArray, updateItemsInArray, validateDate, validateEmail, validatePhone, validateUrl };
 //# sourceMappingURL=mtgame-core.js.map