@mtgame/core 0.0.1

package/fesm2015/mtgame-core.js

@@ -0,0 +1,3749 @@
+import { __decorate, __param, __awaiter } from 'tslib';
+import { ɵɵdefineInjectable, Injectable, Optional, Inject, ɵɵinject, Injector, PLATFORM_ID } from '@angular/core';
+import { HttpClient, HttpParams } from '@angular/common/http';
+import { filter, map, delay, switchMap } from 'rxjs/operators';
+import { BehaviorSubject, Observable, of } from 'rxjs';
+import { Subject } from 'rxjs/internal/Subject';
+import { ReplaySubject } from 'rxjs/internal/ReplaySubject';
+import * as Centrifuge from 'centrifuge';
+import { captureException } from '@sentry/browser';
+import { FormGroup } from '@angular/forms';
+import { isPlatformBrowser } from '@angular/common';
+
+const MODEL_MAPPING_FIELDS_KEY = '_mapping_fields_';
+const MODEL_RELATION_KEY = '_relation_';
+const MODEL_TO_FRONT_KEY = '_to_front_';
+const MODEL_TO_BACK_KEY = '_to_back_';
+class BaseModel {
+    constructor(data) {
+        if (data) {
+            for (const key of Object.keys(data)) {
+                this[key] = data[key];
+            }
+        }
+    }
+    static toFront(dto) {
+        return undefined;
+    }
+    static toBack(dto) {
+        return undefined;
+    }
+}
+function enumField(enumClass) {
+    return {
+        toFront: (value) => {
+            if (isNaN(+value)) {
+                return enumClass[value];
+            }
+            else {
+                return value;
+            }
+        },
+        toBack: (value) => {
+            if (isNaN(+value)) {
+                return value;
+            }
+            else {
+                return enumClass[value];
+            }
+        }
+    };
+}
+function listField(modelClass) {
+    return {
+        toFront: (value) => {
+            if (!Array.isArray(value)) {
+                return [];
+            }
+            return modelClass.toFront(value);
+        },
+        toBack: (value) => {
+            if (!Array.isArray(value)) {
+                return [];
+            }
+            return modelClass.toBack(value);
+        }
+    };
+}
+class DateField extends BaseModel {
+    static toFront(date) {
+        if (date) {
+            return new Date(date);
+        }
+        else {
+            return undefined;
+        }
+    }
+    static toBack(date) {
+        if (date) {
+            const dateUtc = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds()));
+            return dateUtc.toISOString().slice(0, 10);
+        }
+        else {
+            return undefined;
+        }
+    }
+}
+class DateTimeField extends BaseModel {
+    static toFront(date) {
+        if (date) {
+            return new Date(date);
+        }
+        else {
+            return undefined;
+        }
+    }
+    static toBack(date) {
+        if (date) {
+            const dateUtc = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds()));
+            return date.toISOString();
+        }
+        else {
+            return undefined;
+        }
+    }
+}
+function ModelInstance(config) {
+    return (target) => {
+        if (config) {
+            if (config.mappingFields) {
+                target[MODEL_MAPPING_FIELDS_KEY] = config.mappingFields;
+            }
+            if (config.relation) {
+                target[MODEL_RELATION_KEY] = config.relation;
+            }
+            target[MODEL_TO_FRONT_KEY] = (dto, path) => {
+                return toFront(target, dto, path);
+            };
+            target[MODEL_TO_BACK_KEY] = (dto, path) => {
+                return toBack(target, dto, path);
+            };
+        }
+    };
+}
+const ToFrontHook = (target, key, descriptor) => {
+    return {
+        value: (...args) => {
+            const parseMethod = target[MODEL_TO_FRONT_KEY];
+            if (parseMethod) {
+                return parseMethod(args[0], (args.length > 1 ? args[1] : undefined));
+            }
+            return undefined;
+        }
+    };
+};
+const ToBackHook = (target, key, descriptor) => {
+    return {
+        value: (...args) => {
+            const parseMethod = target[MODEL_TO_BACK_KEY];
+            if (parseMethod) {
+                return parseMethod(args[0]);
+            }
+            return undefined;
+        }
+    };
+};
+function extractValue(key, data) {
+    if (!data) {
+        return undefined;
+    }
+    const keyParts = key.split('.');
+    if (keyParts.length === 1) {
+        if (key in data) {
+            return data[key];
+        }
+        else {
+            return undefined;
+        }
+    }
+    for (const k of keyParts) {
+        if (data && k in data) {
+            data = data[k];
+        }
+        else {
+            return undefined;
+        }
+    }
+    return data;
+}
+function toFront(modelType, data, path) {
+    // Check if recursion is required
+    if (Array.isArray(data)) {
+        return data.map(item => {
+            return toFront(modelType, item);
+        });
+    }
+    const instance = new modelType();
+    // Mapping fields
+    const mappingFields = modelType[MODEL_MAPPING_FIELDS_KEY];
+    const relation = modelType[MODEL_RELATION_KEY];
+    if (mappingFields) {
+        for (const backField of Object.keys(mappingFields)) {
+            const frontField = mappingFields[backField];
+            const value = extractValue(backField, data);
+            if (relation && relation.hasOwnProperty(frontField)) {
+                instance[frontField] = relation[frontField].toFront(value);
+            }
+            else {
+                instance[frontField] = value;
+            }
+        }
+    }
+    return instance;
+}
+function toBack(modelType, instance, path) {
+    if (!instance) {
+        return instance;
+    }
+    // Check if recursion is required
+    if (Array.isArray(instance)) {
+        return instance.map(item => {
+            return toBack(modelType, item);
+        });
+    }
+    const data = {};
+    const mappingFields = modelType[MODEL_MAPPING_FIELDS_KEY];
+    const relation = modelType[MODEL_RELATION_KEY];
+    if (mappingFields) {
+        for (const backField of Object.keys(mappingFields)) {
+            const frontField = mappingFields[backField];
+            if (relation && relation.hasOwnProperty(frontField) && instance[frontField] !== undefined) {
+                data[backField] = relation[frontField].toBack(instance[frontField]);
+            }
+            else {
+                data[backField] = instance[frontField];
+            }
+        }
+    }
+    return data;
+}
+
+var FileEngine;
+(function (FileEngine) {
+    FileEngine[FileEngine["django"] = 1] = "django";
+    FileEngine[FileEngine["s3"] = 2] = "s3";
+})(FileEngine || (FileEngine = {}));
+let File = class File {
+    static toFront(data) {
+        return null;
+    }
+    static toBack(file) {
+        return null;
+    }
+};
+__decorate([
+    ToFrontHook
+], File, "toFront", null);
+__decorate([
+    ToBackHook
+], File, "toBack", null);
+File = __decorate([
+    ModelInstance({
+        mappingFields: {
+            id: 'id',
+            name: 'name',
+            path: 'path',
+            mime_type: 'mimeType',
+            size: 'size',
+            engine: 'engine',
+        },
+        relation: {
+            engine: enumField(FileEngine)
+        }
+    })
+], File);
+
+var SportTypes;
+(function (SportTypes) {
+    SportTypes[SportTypes["basketball"] = 1] = "basketball";
+    SportTypes[SportTypes["volleyball"] = 2] = "volleyball";
+    SportTypes[SportTypes["classic_basketball"] = 3] = "classic_basketball";
+    SportTypes[SportTypes["streetball"] = 4] = "streetball";
+})(SportTypes || (SportTypes = {}));
+let Sport = class Sport extends BaseModel {
+    isBasketball() {
+        return this.id === SportTypes.basketball || this.parentId === SportTypes.basketball;
+    }
+    isClassicBasketball() {
+        return this.id === SportTypes.classic_basketball;
+    }
+    isVolleyball() {
+        return this.id === SportTypes.volleyball || this.parentId === SportTypes.volleyball;
+    }
+    isStreetball() {
+        return this.id === SportTypes.streetball;
+    }
+    static toFront(data) {
+        return null;
+    }
+    static toBack(sport) {
+        return null;
+    }
+};
+__decorate([
+    ToFrontHook
+], Sport, "toFront", null);
+__decorate([
+    ToBackHook
+], Sport, "toBack", null);
+Sport = __decorate([
+    ModelInstance({
+        mappingFields: {
+            id: 'id',
+            name: 'name',
+            parent_id: 'parentId',
+            sub_sports: 'subSports'
+        }
+    })
+], Sport);
+
+let UserProfile = class UserProfile {
+    static toFront(value) { }
+    static toBack(value) { }
+};
+__decorate([
+    ToFrontHook
+], UserProfile, "toFront", null);
+__decorate([
+    ToBackHook
+], UserProfile, "toBack", null);
+UserProfile = __decorate([
+    ModelInstance({
+        mappingFields: {
+            id: 'id',
+            user_id: 'userId',
+            height: 'height',
+            weight: 'weight'
+        }
+    })
+], UserProfile);
+
+let City = class City extends BaseModel {
+    static toFront(value) { }
+    static toBack(value) { }
+};
+__decorate([
+    ToFrontHook
+], City, "toFront", null);
+__decorate([
+    ToBackHook
+], City, "toBack", null);
+City = __decorate([
+    ModelInstance({
+        mappingFields: {
+            id: 'id',
+            name: 'name'
+        }
+    })
+], City);
+
+var GameBasketballPosition;
+(function (GameBasketballPosition) {
+    GameBasketballPosition[GameBasketballPosition["point_guard"] = 1] = "point_guard";
+    GameBasketballPosition[GameBasketballPosition["shooting_guard"] = 2] = "shooting_guard";
+    GameBasketballPosition[GameBasketballPosition["small_forward"] = 3] = "small_forward";
+    GameBasketballPosition[GameBasketballPosition["power_forward"] = 4] = "power_forward";
+    GameBasketballPosition[GameBasketballPosition["center"] = 5] = "center";
+})(GameBasketballPosition || (GameBasketballPosition = {}));
+var WorkHand;
+(function (WorkHand) {
+    WorkHand[WorkHand["left"] = 1] = "left";
+    WorkHand[WorkHand["right"] = 2] = "right";
+})(WorkHand || (WorkHand = {}));
+let BasketballProfile = class BasketballProfile extends BaseModel {
+    static toFront(value) {
+    }
+    static toBack(value) {
+    }
+};
+__decorate([
+    ToFrontHook
+], BasketballProfile, "toFront", null);
+__decorate([
+    ToBackHook
+], BasketballProfile, "toBack", null);
+BasketballProfile = __decorate([
+    ModelInstance({
+        mappingFields: {
+            id: 'id',
+            user_id: 'userId',
+            position: 'position',
+            work_hand: 'workHand'
+        },
+        relation: {
+            position: enumField(GameBasketballPosition),
+            workHand: enumField(WorkHand)
+        }
+    })
+], BasketballProfile);
+
+var GameVolleyballPosition;
+(function (GameVolleyballPosition) {
+    GameVolleyballPosition[GameVolleyballPosition["setter"] = 1] = "setter";
+    GameVolleyballPosition[GameVolleyballPosition["libero"] = 2] = "libero";
+    GameVolleyballPosition[GameVolleyballPosition["middle_player"] = 3] = "middle_player";
+    GameVolleyballPosition[GameVolleyballPosition["receiver_attacker"] = 4] = "receiver_attacker";
+    GameVolleyballPosition[GameVolleyballPosition["dioganal"] = 5] = "dioganal";
+})(GameVolleyballPosition || (GameVolleyballPosition = {}));
+var VolleyballWorkHand;
+(function (VolleyballWorkHand) {
+    VolleyballWorkHand[VolleyballWorkHand["left"] = 1] = "left";
+    VolleyballWorkHand[VolleyballWorkHand["right"] = 2] = "right";
+})(VolleyballWorkHand || (VolleyballWorkHand = {}));
+let VolleyballProfile = class VolleyballProfile extends BaseModel {
+    static toFront(value) {
+    }
+    static toBack(value) {
+    }
+};
+__decorate([
+    ToFrontHook
+], VolleyballProfile, "toFront", null);
+__decorate([
+    ToBackHook
+], VolleyballProfile, "toBack", null);
+VolleyballProfile = __decorate([
+    ModelInstance({
+        mappingFields: {
+            id: 'id',
+            user_id: 'userId',
+            position: 'position',
+            work_hand: 'workHand'
+        },
+        relation: {
+            position: enumField(GameVolleyballPosition),
+            workHand: enumField(VolleyballWorkHand)
+        }
+    })
+], VolleyballProfile);
+
+var UserGender;
+(function (UserGender) {
+    UserGender[UserGender["male"] = 1] = "male";
+    UserGender[UserGender["female"] = 2] = "female";
+})(UserGender || (UserGender = {}));
+let User = class User extends BaseModel {
+    static toFront(data) {
+        return null;
+    }
+    static toBack(user) {
+        return null;
+    }
+    get fullName() {
+        return [this.lastName, this.firstName].filter(s => s).join(' ');
+    }
+    get shortName() {
+        return [this.lastName, this.firstName].filter(s => s).join(' ');
+    }
+    get initials() {
+        return [this.lastName, this.firstName].filter(s => s).map(s => s.substr(0, 1)).join('');
+    }
+    get age() {
+        if (!this.birthDate) {
+            return null;
+        }
+        const diff = (new Date()).getTime() - this.birthDate.getTime();
+        return Math.floor(diff / (365 * 86400 * 1000));
+    }
+};
+__decorate([
+    ToFrontHook
+], User, "toFront", null);
+__decorate([
+    ToBackHook
+], User, "toBack", null);
+User = __decorate([
+    ModelInstance({
+        mappingFields: {
+            id: 'id',
+            last_name: 'lastName',
+            first_name: 'firstName',
+            middle_name: 'middleName',
+            email: 'email',
+            phone: 'phone',
+            birth_date: 'birthDate',
+            photo: 'photo',
+            profile: 'profile',
+            basketball_profile: 'basketballProfile',
+            volleyball_profile: 'volleyballProfile',
+            wizards: 'wizards',
+            city: 'city',
+            gender: 'gender',
+            is_active: 'isActive',
+        },
+        relation: {
+            birthDate: DateField,
+            photo: File,
+            profile: UserProfile,
+            basketballProfile: BasketballProfile,
+            volleyballProfile: VolleyballProfile,
+            city: City,
+            gender: enumField(UserGender)
+        }
+    })
+], User);
+
+let Team = class Team extends BaseModel {
+    getEmptyLogoClass() {
+        const classList = ['empty-logo'];
+        if (this.sport.isBasketball()) {
+            classList.push('empty-logo-basketball');
+        }
+        if (this.sport.isVolleyball()) {
+            classList.push('empty-logo-volleyball');
+        }
+        return classList.join(' ');
+    }
+    static toFront(data) {
+        return null;
+    }
+    static toBack(team) {
+        return null;
+    }
+};
+__decorate([
+    ToFrontHook
+], Team, "toFront", null);
+__decorate([
+    ToBackHook
+], Team, "toBack", null);
+Team = __decorate([
+    ModelInstance({
+        mappingFields: {
+            id: 'id',
+            name: 'name',
+            sport: 'sport',
+            logo: 'logo',
+            owner: 'owner',
+            city: 'city',
+            users_count: 'usersCount',
+            won_games_count: 'wonGamesCount',
+            games_count: 'gamesCount',
+            score_sum: 'scoreSum',
+            closest_game_datetime: 'closestGameDatetime',
+        },
+        relation: {
+            sport: Sport,
+            logo: File,
+            owner: User,
+            city: City,
+            closestGameDatetime: DateField,
+        }
+    })
+], Team);
+
+let Organization = class Organization extends BaseModel {
+    static toFront(data) { }
+    static toBack(data) { }
+};
+__decorate([
+    ToFrontHook
+], Organization, "toFront", null);
+__decorate([
+    ToBackHook
+], Organization, "toBack", null);
+Organization = __decorate([
+    ModelInstance({
+        mappingFields: {
+            id: 'id',
+            owner_id: 'ownerId',
+            owner: 'owner',
+        },
+        relation: {
+            owner: User,
+        }
+    })
+], Organization);
+
+let League = class League extends BaseModel {
+    static toFront(data) { }
+    static toBack(data) { }
+    get vkLink() {
+        return this.socialLinks.find(link => link.substr(0, 15) === 'https://vk.com/');
+    }
+    get fbLink() {
+        return this.socialLinks.find(link => link.substr(0, 25) === 'https://www.facebook.com/');
+    }
+    get instaLink() {
+        return this.socialLinks.find(link => link.substr(0, 25) === 'https://www.instagram.com');
+    }
+};
+__decorate([
+    ToFrontHook
+], League, "toFront", null);
+__decorate([
+    ToBackHook
+], League, "toBack", null);
+League = __decorate([
+    ModelInstance({
+        mappingFields: {
+            id: 'id',
+            logo: 'logo',
+            contact_email: 'contactEmail',
+            contact_phone: 'contactPhone',
+            name: 'name',
+            alias: 'alias',
+            sport: 'sport',
+            description: 'description',
+            social_links: 'socialLinks',
+            links: 'links',
+            organization: 'organization',
+            tournaments_count: 'tournamentsCount',
+            closest_game_datetime: 'closestGameDatetime',
+            cover: 'cover',
+        },
+        relation: {
+            organization: Organization,
+            logo: File,
+            cover: File,
+            sport: Sport
+        }
+    })
+], League);
+
+var TournamentTypes;
+(function (TournamentTypes) {
+    TournamentTypes["group"] = "group";
+    TournamentTypes["elimination"] = "elimination";
+    TournamentTypes["fiba"] = "fiba";
+})(TournamentTypes || (TournamentTypes = {}));
+var TournamentStatuses;
+(function (TournamentStatuses) {
+    TournamentStatuses[TournamentStatuses["open"] = 0] = "open";
+    TournamentStatuses[TournamentStatuses["in_progress"] = 1] = "in_progress";
+    TournamentStatuses[TournamentStatuses["closed"] = 2] = "closed";
+})(TournamentStatuses || (TournamentStatuses = {}));
+var TournamentGender;
+(function (TournamentGender) {
+    TournamentGender[TournamentGender["male"] = 1] = "male";
+    TournamentGender[TournamentGender["female"] = 2] = "female";
+    TournamentGender[TournamentGender["all"] = 3] = "all";
+})(TournamentGender || (TournamentGender = {}));
+var BasketballStatisticTypes;
+(function (BasketballStatisticTypes) {
+    BasketballStatisticTypes[BasketballStatisticTypes["standard"] = 1] = "standard";
+    BasketballStatisticTypes[BasketballStatisticTypes["light"] = 2] = "light";
+    BasketballStatisticTypes[BasketballStatisticTypes["extended"] = 3] = "extended";
+})(BasketballStatisticTypes || (BasketballStatisticTypes = {}));
+let TournamentSettings = class TournamentSettings extends BaseModel {
+    static toFront(data) { }
+    static toBack(data) { }
+};
+__decorate([
+    ToFrontHook
+], TournamentSettings, "toFront", null);
+__decorate([
+    ToBackHook
+], TournamentSettings, "toBack", null);
+TournamentSettings = __decorate([
+    ModelInstance({
+        mappingFields: {
+            id: 'id',
+            gender: 'gender',
+            age_from: 'ageFrom',
+            age_to: 'ageTo',
+            max_team_players: 'maxTeamPlayers',
+            max_game_players: 'maxGamePlayers',
+            type: 'type',
+            tours_count: 'toursCount',
+            periods_count: 'periodsCount',
+            period_time: 'periodTime',
+            overtime_type: 'overtimeType',
+            overtime_time: 'overtimeTime',
+            overtime_score: 'overtimeScore',
+            game_type: 'gameType',
+            timeout_count: 'timeoutCount',
+            timeout_time: 'timeoutTime',
+            substitute_count: 'substituteCount',
+            game_up_to_score: 'gameUpToScore',
+            volleyball_score_in_set: 'volleyballScoreInSet',
+            volleyball_score_in_last_set: 'volleyballScoreInLastSet',
+            manage_team_application: 'manageTeamApplication',
+            recruitment_is_open: 'recruitmentIsOpen',
+            transfer_is_open: 'transferIsOpen',
+            basketball_statistic_type: 'basketballStatisticType',
+        },
+        relation: {
+            type: enumField(TournamentTypes),
+            gender: enumField(TournamentGender),
+            basketballStatisticType: enumField(BasketballStatisticTypes),
+        }
+    })
+], TournamentSettings);
+let TournamentTeamWinner = class TournamentTeamWinner extends BaseModel {
+    static toFront(data) { }
+    static toBack(data) { }
+};
+__decorate([
+    ToFrontHook
+], TournamentTeamWinner, "toFront", null);
+__decorate([
+    ToBackHook
+], TournamentTeamWinner, "toBack", null);
+TournamentTeamWinner = __decorate([
+    ModelInstance({
+        mappingFields: {
+            id: 'id',
+            team_id: 'teamId',
+            tournament_id: 'tournamentId',
+            team: 'team',
+            points: 'points',
+        },
+        relation: {
+            team: Team,
+        }
+    })
+], TournamentTeamWinner);
+let Tournament = class Tournament extends BaseModel {
+    getEmptyLogoClass() {
+        const classList = ['empty-logo'];
+        if (this.sport.isBasketball()) {
+            classList.push('empty-logo-basketball');
+        }
+        if (this.sport.isVolleyball()) {
+            classList.push('empty-logo-volleyball');
+        }
+        return classList.join(' ');
+    }
+    static toFront(data) { }
+    static toBack(data) { }
+};
+__decorate([
+    ToFrontHook
+], Tournament, "toFront", null);
+__decorate([
+    ToBackHook
+], Tournament, "toBack", null);
+Tournament = __decorate([
+    ModelInstance({
+        mappingFields: {
+            id: 'id',
+            name: 'name',
+            alias: 'alias',
+            logo: 'logo',
+            cover: 'cover',
+            preview_image: 'previewImage',
+            city: 'city',
+            sport: 'sport',
+            location: 'location',
+            description: 'description',
+            date: 'date',
+            price: 'price',
+            regulation_files: 'regulationFiles',
+            settings: 'settings',
+            league: 'league',
+            teams_count: 'teamsCount',
+            closest_game_datetime: 'closestGameDatetime',
+            status: 'status',
+            team_winner: 'teamWinner'
+        },
+        relation: {
+            logo: File,
+            cover: File,
+            city: City,
+            sport: Sport,
+            regulationFile: File,
+            settings: TournamentSettings,
+            date: DateTimeField,
+            league: League,
+            status: enumField(TournamentStatuses),
+            teamWinner: TournamentTeamWinner
+        }
+    })
+], Tournament);
+
+var OvertimeTypes;
+(function (OvertimeTypes) {
+    OvertimeTypes[OvertimeTypes["to_score_total"] = 0] = "to_score_total";
+    OvertimeTypes[OvertimeTypes["to_score_diff"] = 1] = "to_score_diff";
+    OvertimeTypes[OvertimeTypes["time"] = 2] = "time";
+})(OvertimeTypes || (OvertimeTypes = {}));
+let BasketballGameConfig = class BasketballGameConfig extends BaseModel {
+    static toFront(data) { }
+    static toBack(data) { }
+};
+__decorate([
+    ToFrontHook
+], BasketballGameConfig, "toFront", null);
+__decorate([
+    ToBackHook
+], BasketballGameConfig, "toBack", null);
+BasketballGameConfig = __decorate([
+    ModelInstance({
+        mappingFields: {
+            periods_count: 'periodsCount',
+            period_time: 'periodTime',
+            game_up_to_score: 'gameUpToScore',
+            overtime_type: 'overtimeType',
+            overtime_time: 'overtimeTime',
+            overtime_score: 'overtimeScore',
+            max_game_players: 'maxGamePlayers',
+            timeout_count: 'timeoutCount',
+            overtime_timeout_count: 'overtimeTimeoutCount',
+            timeout_time: 'timeoutTime',
+            statistic_type: 'statisticType',
+        },
+        relation: {
+            overtimeType: enumField(OvertimeTypes),
+            statisticType: enumField(BasketballStatisticTypes)
+        }
+    })
+], BasketballGameConfig);
+
+var VolleyballGameTypes;
+(function (VolleyballGameTypes) {
+    VolleyballGameTypes[VolleyballGameTypes["best_of_five"] = 1] = "best_of_five";
+    VolleyballGameTypes[VolleyballGameTypes["best_of_three"] = 2] = "best_of_three";
+})(VolleyballGameTypes || (VolleyballGameTypes = {}));
+let VolleyballGameConfig = class VolleyballGameConfig extends BaseModel {
+    get setsCount() {
+        return this.gameType === VolleyballGameTypes.best_of_three ? 3 : 5;
+    }
+    getSetMaxScore(set) {
+        return set === this.setsCount ? this.scoreInLastSet : this.scoreInSet;
+    }
+    static toFront(data) { }
+    static toBack(data) { }
+};
+__decorate([
+    ToFrontHook
+], VolleyballGameConfig, "toFront", null);
+__decorate([
+    ToBackHook
+], VolleyballGameConfig, "toBack", null);
+VolleyballGameConfig = __decorate([
+    ModelInstance({
+        mappingFields: {
+            game_type: 'gameType',
+            timeout_count: 'timeoutCount',
+            timeout_time: 'timeoutTime',
+            substitute_count: 'substituteCount',
+            score_in_set: 'scoreInSet',
+            score_in_last_set: 'scoreInLastSet'
+        },
+        relation: {
+            gameType: enumField(VolleyballGameTypes)
+        }
+    })
+], VolleyballGameConfig);
+
+let LeagueCourt = class LeagueCourt extends BaseModel {
+    static toFront(data) { }
+    static toBack(data) { }
+};
+__decorate([
+    ToFrontHook
+], LeagueCourt, "toFront", null);
+__decorate([
+    ToBackHook
+], LeagueCourt, "toBack", null);
+LeagueCourt = __decorate([
+    ModelInstance({
+        mappingFields: {
+            id: 'id',
+            name: 'name',
+            address: 'address',
+            league_id: 'leagueId'
+        }
+    })
+], LeagueCourt);
+
+let MediaItem = class MediaItem extends BaseModel {
+    get isVideo() {
+        return Boolean(this.videoUrl);
+    }
+    static toFront(data) { }
+    static toBack(data) { }
+};
+__decorate([
+    ToFrontHook
+], MediaItem, "toFront", null);
+__decorate([
+    ToBackHook
+], MediaItem, "toBack", null);
+MediaItem = __decorate([
+    ModelInstance({
+        mappingFields: {
+            id: 'id',
+            original_photo: 'originalPhoto',
+            list_photo: 'listPhoto',
+            detail_photo: 'detailPhoto',
+            game: 'game',
+            tournament: 'tournament',
+            game_id: 'gameId',
+            tournament_id: 'tournament_id',
+            video_url: 'videoUrl',
+            video_preview: 'videoPreview',
+        },
+        relation: {
+            originalPhoto: File,
+            listPhoto: File,
+            detailPhoto: File,
+            videoPreview: File
+        }
+    })
+], MediaItem);
+
+var GameStatuses;
+(function (GameStatuses) {
+    GameStatuses[GameStatuses["open"] = 1] = "open";
+    GameStatuses[GameStatuses["in_progress"] = 2] = "in_progress";
+    GameStatuses[GameStatuses["closed"] = 3] = "closed";
+    GameStatuses[GameStatuses["archived"] = 4] = "archived";
+    GameStatuses[GameStatuses["draft"] = 5] = "draft";
+})(GameStatuses || (GameStatuses = {}));
+var GameResultTypes;
+(function (GameResultTypes) {
+    GameResultTypes[GameResultTypes["team_won"] = 1] = "team_won";
+    GameResultTypes[GameResultTypes["competitor_team_won"] = 2] = "competitor_team_won";
+    GameResultTypes[GameResultTypes["team_technical_defeat"] = 3] = "team_technical_defeat";
+    GameResultTypes[GameResultTypes["competitor_team_technical_defeat"] = 4] = "competitor_team_technical_defeat";
+})(GameResultTypes || (GameResultTypes = {}));
+let Game = class Game extends BaseModel {
+    get scoreByPeriodList() {
+        if (!this.scoreByPeriod) {
+            return [];
+        }
+        return Object.keys(this.scoreByPeriod).map(period => ({
+            period: +period,
+            teamScore: this.scoreByPeriod[period][0],
+            competitorTeamScore: this.scoreByPeriod[period][1]
+        }));
+    }
+    get isClosed() {
+        return this.status === GameStatuses.closed;
+    }
+    get isTeamWon() {
+        return this.teamScore > this.competitorTeamScore;
+    }
+    get isCompetitorTeamWon() {
+        return this.competitorTeamScore > this.teamScore;
+    }
+    get teamWinnerId() {
+        if (this.status !== GameStatuses.closed) {
+            return null;
+        }
+        if (this.teamScore === this.competitorTeamScore) {
+            return null;
+        }
+        if (this.team.id) {
+            return this.teamScore > this.competitorTeamScore ? this.team.id : this.competitorTeam.id;
+        }
+        else {
+            return this.teamScore > this.competitorTeamScore ? this.teamId : this.competitorTeamId;
+        }
+    }
+    static toFront(data) { }
+    static toBack(data) { }
+};
+__decorate([
+    ToFrontHook
+], Game, "toFront", null);
+__decorate([
+    ToBackHook
+], Game, "toBack", null);
+Game = __decorate([
+    ModelInstance({
+        mappingFields: {
+            id: 'id',
+            status: 'status',
+            team: 'team',
+            team_id: 'teamId',
+            competitor_team: 'competitorTeam',
+            competitor_team_id: 'competitorTeamId',
+            competitor_team_name: 'competitorTeamName',
+            datetime: 'datetime',
+            location: 'location',
+            team_score: 'teamScore',
+            competitor_team_score: 'competitorTeamScore',
+            result_type: 'resultType',
+            playoff_number: 'playoffNumber',
+            tournament_id: 'tournamentId',
+            tournament_tour: 'tournamentTour',
+            basketball_game_config: 'basketballGameConfig',
+            volleyball_game_config: 'volleyballGameConfig',
+            score_by_period: 'scoreByPeriod',
+            playoff_stage: 'playoffStage',
+            tournament_stage_id: 'tournamentStageId',
+            tournament_playoff_id: 'tournamentPlayoffId',
+            tournament_court: 'tournamentCourt',
+            media_count: 'mediaCount',
+            media: 'media',
+        },
+        relation: {
+            status: enumField(GameStatuses),
+            team: Team,
+            competitorTeam: Team,
+            datetime: DateTimeField,
+            resultType: enumField(GameResultTypes),
+            basketballGameConfig: BasketballGameConfig,
+            volleyballGameConfig: VolleyballGameConfig,
+            tournamentCourt: LeagueCourt,
+            media: listField(MediaItem),
+        }
+    })
+], Game);
+
+var TeamUserRole;
+(function (TeamUserRole) {
+    TeamUserRole[TeamUserRole["member"] = 1] = "member";
+    TeamUserRole[TeamUserRole["moderator"] = 2] = "moderator";
+    TeamUserRole[TeamUserRole["admin"] = 3] = "admin";
+})(TeamUserRole || (TeamUserRole = {}));
+let TeamUser = class TeamUser extends BaseModel {
+    static toFront(data) { }
+    static toBack(teamPlayer) { }
+};
+__decorate([
+    ToFrontHook
+], TeamUser, "toFront", null);
+__decorate([
+    ToBackHook
+], TeamUser, "toBack", null);
+TeamUser = __decorate([
+    ModelInstance({
+        mappingFields: {
+            id: 'id',
+            team_id: 'teamId',
+            user: 'user',
+            role: 'role',
+            number: 'number',
+            team: 'team',
+        },
+        relation: {
+            user: User,
+            team: Team,
+            role: enumField(TeamUserRole)
+        }
+    })
+], TeamUser);
+
+let TournamentGroup = class TournamentGroup extends BaseModel {
+    static toFront(data) { }
+    static toBack(data) { }
+};
+__decorate([
+    ToFrontHook
+], TournamentGroup, "toFront", null);
+__decorate([
+    ToBackHook
+], TournamentGroup, "toBack", null);
+TournamentGroup = __decorate([
+    ModelInstance({
+        mappingFields: {
+            id: 'id',
+            name: 'name',
+            tournament_stage_id: 'tournamentStageId'
+        }
+    })
+], TournamentGroup);
+
+let TournamentTeam = class TournamentTeam extends BaseModel {
+    get gamesWonPercent() {
+        if (!this.gamesCount) {
+            return 0;
+        }
+        return Math.floor(1000 * this.wonGamesCount / this.gamesCount) / 10;
+    }
+    static toFront(data) { }
+    static toBack(data) { }
+};
+__decorate([
+    ToFrontHook
+], TournamentTeam, "toFront", null);
+__decorate([
+    ToBackHook
+], TournamentTeam, "toBack", null);
+TournamentTeam = __decorate([
+    ModelInstance({
+        mappingFields: {
+            id: 'id',
+            team_id: 'teamId',
+            tournament_id: 'tournamentId',
+            tournament: 'tournament',
+            team: 'team',
+            group: 'group',
+            games_count: 'gamesCount',
+            won_games_count: 'wonGamesCount',
+            last_games_count: 'lastGamesCount',
+            last_games_won: 'lastGamesWon',
+            score_sum: 'scoreSum',
+            missed_sum: 'missedSum',
+            score_points_sum: 'scorePointsSum',
+            missed_points_sum: 'missedPointsSum',
+            points: 'points',
+            users_count: 'usersCount',
+            games: 'games',
+            notifications_count: 'notificationsCount',
+        },
+        relation: {
+            tournament: Tournament,
+            team: Team,
+            group: TournamentGroup,
+            games: Game,
+        }
+    })
+], TournamentTeam);
+
+let TournamentDisqualification = class TournamentDisqualification extends BaseModel {
+    static toFront(data) { }
+    static toBack(data) { }
+};
+__decorate([
+    ToFrontHook
+], TournamentDisqualification, "toFront", null);
+__decorate([
+    ToBackHook
+], TournamentDisqualification, "toBack", null);
+TournamentDisqualification = __decorate([
+    ModelInstance({
+        mappingFields: {
+            id: 'id',
+            tournament_team_user_id: 'tournamentTeamUserId',
+            date_from: 'dateFrom',
+            date_to: 'dateTo',
+            matches_count: 'matchesCount',
+        },
+        relation: {
+            dateFrom: DateField,
+            dateTo: DateField,
+        }
+    })
+], TournamentDisqualification);
+
+let TournamentTeamUser = class TournamentTeamUser extends BaseModel {
+    get fullName() {
+        return [this.lastName, this.firstName, this.middleName].filter(s => s).join(' ');
+    }
+    get shortName() {
+        return [this.lastName, this.firstName].filter(s => s).join(' ');
+    }
+    get initials() {
+        return [this.lastName, this.firstName].filter(s => s).map(s => s.substr(0, 1)).join('');
+    }
+    static toFront(data) { }
+    static toBack(data) { }
+};
+__decorate([
+    ToFrontHook
+], TournamentTeamUser, "toFront", null);
+__decorate([
+    ToBackHook
+], TournamentTeamUser, "toBack", null);
+TournamentTeamUser = __decorate([
+    ModelInstance({
+        mappingFields: {
+            id: 'id',
+            tournament_team: 'tournamentTeam',
+            team_user: 'teamUser',
+            disqualified: 'disqualified',
+            first_name: 'firstName',
+            last_name: 'lastName',
+            middle_name: 'middleName',
+            photo: 'photo',
+            disqualification: 'disqualification',
+            has_changes: 'hasChanges',
+        },
+        relation: {
+            tournamentTeam: TournamentTeam,
+            teamUser: TeamUser,
+            photo: File,
+            disqualification: TournamentDisqualification,
+        }
+    })
+], TournamentTeamUser);
+
+let GameUser = class GameUser extends BaseModel {
+    static toFront(data) { }
+    static toBack(data) { }
+};
+__decorate([
+    ToFrontHook
+], GameUser, "toFront", null);
+__decorate([
+    ToBackHook
+], GameUser, "toBack", null);
+GameUser = __decorate([
+    ModelInstance({
+        mappingFields: {
+            id: 'id',
+            game_id: 'gameId',
+            team_user: 'teamUser',
+            tournament_team_user: 'tournamentTeamUser',
+            updated_at: 'updatedAt'
+        },
+        relation: {
+            teamUser: TeamUser,
+            tournamentTeamUser: TournamentTeamUser,
+            updatedAt: DateTimeField,
+        }
+    })
+], GameUser);
+
+function updateItemInArray(data, item, force = false, checkFunction) {
+    if (!Array.isArray(data)) {
+        return data;
+    }
+    return data.map(v => {
+        if (checkFunction && isFunction(checkFunction)) {
+            if (!checkFunction(v)) {
+                return v;
+            }
+        }
+        else if (v.id !== item.id) {
+            return v;
+        }
+        if (v.updatedAt && item.updatedAt && !force) {
+            return v.updatedAt > item.updatedAt ? v : item;
+        }
+        return item;
+    });
+}
+function updateItemsInArray(data, items, force = false, checkFunction) {
+    items.forEach(item => {
+        data = updateItemInArray(data, item, force, checkFunction);
+    });
+    return data;
+}
+function patchItemInArray(data, item, checkFunction) {
+    if (!Array.isArray(data)) {
+        return data;
+    }
+    return data.map(v => {
+        if (checkFunction && isFunction(checkFunction)) {
+            if (!checkFunction(v)) {
+                return v;
+            }
+        }
+        else if (v.id !== item.id) {
+            return v;
+        }
+        return Object.assign(v, item);
+    });
+}
+function addItemInArray(data, item, atEnd = false, checkFunction) {
+    if (!Array.isArray(data)) {
+        return [item];
+    }
+    if (data.find(i => isFunction(checkFunction) ? checkFunction(i) : i.id === item.id)) {
+        return data;
+    }
+    return atEnd
+        ? [...data, item]
+        : [item, ...data];
+}
+function addItemsInArray(data, items, atEnd = false, checkFunction) {
+    (!atEnd
+        ? Object.assign([], items).reverse()
+        : items).forEach(item => {
+        data = addItemInArray(data, item, atEnd, checkFunction);
+    });
+    return data;
+}
+function deleteItemFromArray(data, item) {
+    if (!Array.isArray(data)) {
+        return [];
+    }
+    if (isFunction(item)) {
+        return data.filter(i => !item(i));
+    }
+    else {
+        return data.filter(v => v.id !== item.id);
+    }
+}
+function isFunction(functionToCheck) {
+    return functionToCheck && {}.toString.call(functionToCheck) === '[object Function]';
+}
+
+class Store {
+    constructor(engine) {
+        this.engine = engine;
+        this.data = {};
+    }
+    get(key) {
+        return this.getSubject(key).pipe(filter(item => item !== undefined));
+    }
+    value(key) {
+        return this.getSubject(key).value;
+    }
+    save(key, value) {
+        this.getSubject(key).next(value);
+        if (this.engine) {
+            this.engine.save(key, value);
+        }
+    }
+    appendItem(key, value, checkFunction) {
+        this.save(key, addItemInArray(this.value(key) || [], value, true, checkFunction));
+    }
+    appendItems(key, value, checkFunction) {
+        this.save(key, addItemsInArray(this.value(key) || [], value, true));
+    }
+    prependItem(key, value, checkFunction) {
+        this.save(key, addItemInArray(this.value(key) || [], value, false, checkFunction));
+    }
+    prependItems(key, value, checkFunction) {
+        this.save(key, addItemsInArray(this.value(key) || [], value, false, checkFunction));
+    }
+    updateItem(key, value, force, checkFunction) {
+        this.save(key, updateItemInArray(this.value(key) || [], value, force, checkFunction));
+    }
+    updateItems(key, value, force, checkFunction) {
+        this.save(key, updateItemsInArray(this.value(key) || [], value, force, checkFunction));
+    }
+    deleteItem(key, value) {
+        this.save(key, deleteItemFromArray(this.value(key) || [], value));
+    }
+    dispose() {
+        for (const key of Object.keys(this.data)) {
+            this.data[key].complete();
+            delete this.data[key];
+        }
+    }
+    clearStorageData() {
+        if (this.engine) {
+            this.engine.clear();
+        }
+    }
+    getEngine() {
+        return this.engine;
+    }
+    getSubject(key) {
+        if (!this.data[key]) {
+            this.data[key] = new BehaviorSubject(this.engine ? this.engine.get(key) : undefined);
+        }
+        return this.data[key];
+    }
+}
+
+let BaseService = class BaseService {
+    constructor() {
+        this.store = new Store();
+    }
+    dispose() {
+        this.store.dispose();
+    }
+};
+BaseService.ɵprov = ɵɵdefineInjectable({ factory: function BaseService_Factory() { return new BaseService(); }, token: BaseService, providedIn: "root" });
+BaseService = __decorate([
+    Injectable({ providedIn: 'root' })
+], BaseService);
+
+const CONFIG_STORE_KEY = 'config';
+const CONFIG_DATA = 'mtg-core-config-data';
+let ConfigService = class ConfigService extends BaseService {
+    constructor(configData) {
+        super();
+        this.configData = configData;
+        if (configData) {
+            this.initialize(configData);
+        }
+    }
+    get config$() {
+        return this.store.get(CONFIG_STORE_KEY);
+    }
+    get config() {
+        return this.store.value(CONFIG_STORE_KEY) || {};
+    }
+    initialize(data) {
+        this.store.save(CONFIG_STORE_KEY, data);
+    }
+    set(key, value) {
+        this.store.save(CONFIG_STORE_KEY, Object.assign(Object.assign({}, this.config), { [key]: value }));
+    }
+    get(key) {
+        return this.store.value(CONFIG_STORE_KEY) && this.store.value(CONFIG_STORE_KEY)[key];
+    }
+};
+ConfigService.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [CONFIG_DATA,] }] }
+];
+ConfigService.ɵprov = ɵɵdefineInjectable({ factory: function ConfigService_Factory() { return new ConfigService(ɵɵinject("mtg-core-config-data", 8)); }, token: ConfigService, providedIn: "root" });
+ConfigService = __decorate([
+    Injectable({ providedIn: 'root' }),
+    __param(0, Optional()), __param(0, Inject(CONFIG_DATA))
+], ConfigService);
+
+let BasketballStatistic = class BasketballStatistic extends BaseModel {
+    get totalFouls() {
+        return this.personalFouls + this.technicalFouls + this.unsportsmanlikeFouls;
+    }
+    static toFront(data) { }
+    static toBack(data) { }
+};
+__decorate([
+    ToFrontHook
+], BasketballStatistic, "toFront", null);
+__decorate([
+    ToBackHook
+], BasketballStatistic, "toBack", null);
+BasketballStatistic = __decorate([
+    ModelInstance({
+        mappingFields: {
+            tournament_team_user: 'tournamentTeamUser',
+            team: 'team',
+            team_user: 'teamUser',
+            user: 'user',
+            tournament_team: 'tournamentTeam',
+            month: 'month',
+            win_lose: 'winLose',
+            games_count: 'gamesCount',
+            won_games_count: 'wonGamesCount',
+            points: 'points',
+            two_points_made: 'twoPointsMade',
+            three_points_made: 'threePointsMade',
+            free_throws_made: 'freeThrowsMade',
+            one_points_made: 'onePointsMade',
+            two_point_attempts: 'twoPointAttempts',
+            three_point_attempts: 'threePointAttempts',
+            free_throw_attempts: 'freeThrowAttempts',
+            one_point_attempts: 'onePointAttempts',
+            two_point_percent: 'twoPointPercent',
+            three_point_percent: 'threePointPercent',
+            free_throw_percent: 'freeThrowPercent',
+            one_point_percent: 'onePointPercent',
+            assists: 'assists',
+            blocks: 'blocks',
+            rebounds: 'rebounds',
+            offensive_rebounds: 'offensiveRebounds',
+            defensive_rebounds: 'defensiveRebounds',
+            steals: 'steals',
+            turnovers: 'turnovers',
+            personal_fouls: 'personalFouls',
+            technical_fouls: 'technicalFouls',
+            unsportsmanlike_fouls: 'unsportsmanlikeFouls',
+            newbie: 'newbie',
+        },
+        relation: {
+            tournamentTeamUser: TournamentTeamUser,
+            team: Team,
+            teamUser: TeamUser,
+            user: User,
+            tournamentTeam: TournamentTeam,
+            month: DateField
+        }
+    })
+], BasketballStatistic);
+
+let BasketballGameTeamStatistic = class BasketballGameTeamStatistic extends BaseModel {
+    static toFront(data) { }
+    static toBack(data) { }
+};
+__decorate([
+    ToFrontHook
+], BasketballGameTeamStatistic, "toFront", null);
+__decorate([
+    ToBackHook
+], BasketballGameTeamStatistic, "toBack", null);
+BasketballGameTeamStatistic = __decorate([
+    ModelInstance({
+        mappingFields: {
+            team: 'team',
+            competitor_team: 'competitorTeam'
+        },
+        relation: {
+            team: BasketballStatistic,
+            competitorTeam: BasketballStatistic
+        }
+    })
+], BasketballGameTeamStatistic);
+
+let BasketballGameStatistic = class BasketballGameStatistic extends BaseModel {
+    get id() {
+        return this.gameUserId;
+    }
+    static toFront(data) { }
+    static toBack(data) { }
+    get totalFouls() {
+        return (this.personalFouls || 0) + (this.technicalFouls || 0) + (this.unsportsmanlikeFouls || 0);
+    }
+};
+__decorate([
+    ToFrontHook
+], BasketballGameStatistic, "toFront", null);
+__decorate([
+    ToBackHook
+], BasketballGameStatistic, "toBack", null);
+BasketballGameStatistic = __decorate([
+    ModelInstance({
+        mappingFields: {
+            game_user_id: 'gameUserId',
+            points: 'points',
+            free_throws_made: 'freeThrowsMade',
+            two_points_made: 'twoPointsMade',
+            three_points_made: 'threePointsMade',
+            one_points_made: 'onePointsMade',
+            two_point_attempts: 'twoPointAttempts',
+            three_point_attempts: 'threePointAttempts',
+            free_throw_attempts: 'freeThrowAttempts',
+            one_point_attempts: 'onePointAttempts',
+            assists: 'assists',
+            blocks: 'blocks',
+            rebounds: 'rebounds',
+            offensive_rebounds: 'offensiveRebounds',
+            defensive_rebounds: 'defensiveRebounds',
+            steals: 'steals',
+            turnovers: 'turnovers',
+            personal_fouls: 'personalFouls',
+            technical_fouls: 'technicalFouls',
+            unsportsmanlike_fouls: 'unsportsmanlikeFouls',
+            updated_at: 'updatedAt',
+        },
+        relation: {
+            updatedAt: DateTimeField,
+        }
+    })
+], BasketballGameStatistic);
+
+var BasketballGameLogTypes;
+(function (BasketballGameLogTypes) {
+    BasketballGameLogTypes[BasketballGameLogTypes["enter_game"] = 1] = "enter_game";
+    BasketballGameLogTypes[BasketballGameLogTypes["exit_game"] = 2] = "exit_game";
+    BasketballGameLogTypes[BasketballGameLogTypes["remove_game"] = 3] = "remove_game";
+    BasketballGameLogTypes[BasketballGameLogTypes["two_point_made"] = 4] = "two_point_made";
+    BasketballGameLogTypes[BasketballGameLogTypes["three_point_made"] = 5] = "three_point_made";
+    BasketballGameLogTypes[BasketballGameLogTypes["free_throw_made"] = 6] = "free_throw_made";
+    BasketballGameLogTypes[BasketballGameLogTypes["two_point_attempt"] = 7] = "two_point_attempt";
+    BasketballGameLogTypes[BasketballGameLogTypes["three_point_attempt"] = 8] = "three_point_attempt";
+    BasketballGameLogTypes[BasketballGameLogTypes["free_throw_attempt"] = 9] = "free_throw_attempt";
+    BasketballGameLogTypes[BasketballGameLogTypes["assist"] = 10] = "assist";
+    BasketballGameLogTypes[BasketballGameLogTypes["block"] = 11] = "block";
+    BasketballGameLogTypes[BasketballGameLogTypes["rebound"] = 12] = "rebound";
+    BasketballGameLogTypes[BasketballGameLogTypes["offensive_rebound"] = 13] = "offensive_rebound";
+    BasketballGameLogTypes[BasketballGameLogTypes["defensive_rebound"] = 14] = "defensive_rebound";
+    BasketballGameLogTypes[BasketballGameLogTypes["steal"] = 15] = "steal";
+    BasketballGameLogTypes[BasketballGameLogTypes["turnover"] = 16] = "turnover";
+    BasketballGameLogTypes[BasketballGameLogTypes["personal_foul"] = 17] = "personal_foul";
+    BasketballGameLogTypes[BasketballGameLogTypes["technical_foul"] = 18] = "technical_foul";
+    BasketballGameLogTypes[BasketballGameLogTypes["unsportsmanlike_foul"] = 19] = "unsportsmanlike_foul";
+    BasketballGameLogTypes[BasketballGameLogTypes["one_point_attempt"] = 20] = "one_point_attempt";
+    BasketballGameLogTypes[BasketballGameLogTypes["one_point_made"] = 21] = "one_point_made";
+    BasketballGameLogTypes[BasketballGameLogTypes["timeout"] = 22] = "timeout";
+})(BasketballGameLogTypes || (BasketballGameLogTypes = {}));
+let BasketballGameLog = class BasketballGameLog extends BaseModel {
+    constructor() {
+        super(...arguments);
+        this.active = true;
+    }
+    isPointsType() {
+        return [
+            BasketballGameLogTypes.two_point_made,
+            BasketballGameLogTypes.three_point_made,
+            BasketballGameLogTypes.free_throw_made,
+            BasketballGameLogTypes.one_point_made,
+        ].indexOf(this.logType) > -1;
+    }
+    isReboundType() {
+        return [
+            BasketballGameLogTypes.rebound,
+            BasketballGameLogTypes.offensive_rebound,
+            BasketballGameLogTypes.defensive_rebound
+        ].indexOf(this.logType) > -1;
+    }
+    isFoulType() {
+        return [
+            BasketballGameLogTypes.personal_foul,
+            BasketballGameLogTypes.technical_foul,
+            BasketballGameLogTypes.unsportsmanlike_foul
+        ].indexOf(this.logType) > -1;
+    }
+    getScore() {
+        const scoreMapping = {
+            [BasketballGameLogTypes.one_point_made]: 1,
+            [BasketballGameLogTypes.free_throw_made]: 1,
+            [BasketballGameLogTypes.two_point_made]: 2,
+            [BasketballGameLogTypes.three_point_made]: 3
+        };
+        return scoreMapping[this.logType];
+    }
+    compare(model) {
+        if (this.time === model.time && this.period === model.period) {
+            return this.datetime.getTime() < model.datetime.getTime() ? 1 : -1;
+        }
+        if (this.period === model.period) {
+            return this.time < model.time ? 1 : -1;
+        }
+        return this.period < model.period ? 1 : -1;
+    }
+    get timeFormatted() {
+        const minutes = Math.floor(this.time / 60);
+        const seconds = this.time - minutes * 60;
+        return `${minutes < 10 ? '0' : ''}${minutes}:${seconds < 10 ? '0' : ''}${seconds}`;
+    }
+    static toFront(value) { }
+    static toBack(value) { }
+};
+__decorate([
+    ToFrontHook
+], BasketballGameLog, "toFront", null);
+__decorate([
+    ToBackHook
+], BasketballGameLog, "toBack", null);
+BasketballGameLog = __decorate([
+    ModelInstance({
+        mappingFields: {
+            id: 'id',
+            unique_id: 'uniqueId',
+            game_id: 'gameId',
+            game_user_id: 'gameUserId',
+            team_id: 'teamId',
+            log_type: 'logType',
+            datetime: 'datetime',
+            time: 'time',
+            period: 'period',
+            active: 'active',
+            is_highlight: 'isHighlight',
+        },
+        relation: {
+            datetime: DateTimeField,
+            logType: enumField(BasketballGameLogTypes),
+        }
+    })
+], BasketballGameLog);
+
+let BasketballGameApi = class BasketballGameApi {
+    constructor(httpClient, configService) {
+        this.httpClient = httpClient;
+        this.configService = configService;
+    }
+    getById(gameId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_basketball_game/${gameId}/`).pipe(map(result => Game.toFront(result))).toPromise();
+        });
+    }
+    getUsers(gameId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_game/${gameId}/users/`).pipe(map(result => GameUser.toFront(result))).toPromise();
+        });
+    }
+    getTeamStatistic(gameId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_basketball_game/${gameId}/team_statistic/`).pipe(map(result => BasketballGameTeamStatistic.toFront(result))).toPromise();
+        });
+    }
+    getUserStatistic(gameId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_basketball_game/${gameId}/user_statistic/`).pipe(map(result => BasketballGameStatistic.toFront(result))).toPromise();
+        });
+    }
+    getLogs(gameId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_basketball_game/${gameId}/logs/`).pipe(map(result => BasketballGameLog.toFront(result))).toPromise();
+        });
+    }
+};
+BasketballGameApi.ctorParameters = () => [
+    { type: HttpClient },
+    { type: ConfigService }
+];
+BasketballGameApi.ɵprov = ɵɵdefineInjectable({ factory: function BasketballGameApi_Factory() { return new BasketballGameApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: BasketballGameApi, providedIn: "root" });
+BasketballGameApi = __decorate([
+    Injectable({ providedIn: 'root' })
+], BasketballGameApi);
+
+var TournamentEventTypes;
+(function (TournamentEventTypes) {
+    TournamentEventTypes[TournamentEventTypes["game_closed"] = 1] = "game_closed";
+    TournamentEventTypes[TournamentEventTypes["media_added"] = 2] = "media_added";
+})(TournamentEventTypes || (TournamentEventTypes = {}));
+let TournamentEvent = class TournamentEvent extends BaseModel {
+    static toFront(data) { }
+    static toBack(data) { }
+};
+__decorate([
+    ToFrontHook
+], TournamentEvent, "toFront", null);
+__decorate([
+    ToBackHook
+], TournamentEvent, "toBack", null);
+TournamentEvent = __decorate([
+    ModelInstance({
+        mappingFields: {
+            id: 'id',
+            game: 'game',
+            tournament: 'tournament',
+            event: 'event',
+            datetime: 'datetime'
+        },
+        relation: {
+            game: Game,
+            tournament: Tournament,
+            datetime: DateField,
+            event: enumField(TournamentEventTypes)
+        }
+    })
+], TournamentEvent);
+
+let LeagueApi = class LeagueApi {
+    constructor(httpClient, configService) {
+        this.httpClient = httpClient;
+        this.configService = configService;
+    }
+    getByAlias(alias) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/league/${alias}/`).pipe(map(result => League.toFront(result))).toPromise();
+        });
+    }
+    getByDomain(domain) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/league/by_domain/${domain}/`).pipe(map(result => League.toFront(result))).toPromise();
+        });
+    }
+    getTournaments(leagueId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/league/${leagueId}/tournaments/`).pipe(map(result => Tournament.toFront(result))).toPromise();
+        });
+    }
+    getEvents(leagueId, page, size, filters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let 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 this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/league/${leagueId}/events/`, { params, observe: 'response' }).pipe(map(result => ({
+                total: +result.headers.get('X-Page-Count'),
+                data: TournamentEvent.toFront(result.body)
+            }))).toPromise();
+        });
+    }
+};
+LeagueApi.ctorParameters = () => [
+    { type: HttpClient },
+    { type: ConfigService }
+];
+LeagueApi.ɵprov = ɵɵdefineInjectable({ factory: function LeagueApi_Factory() { return new LeagueApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: LeagueApi, providedIn: "root" });
+LeagueApi = __decorate([
+    Injectable({ providedIn: 'root' })
+], LeagueApi);
+
+let MediaApi = class MediaApi {
+    constructor(httpClient, configService) {
+        this.httpClient = httpClient;
+        this.configService = configService;
+    }
+    getMedia(mediaId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/media/${mediaId}/`).pipe(map(result => MediaItem.toFront(result))).toPromise();
+        });
+    }
+    getTournamentGameMedia(tournamentId, page, size, filters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let params = new HttpParams().set('page', page.toString()).set('size', size.toString());
+            if (filters) {
+                if (filters.tournamentTour) {
+                    params = params.set('tournament_tour', filters.tournamentTour.toString());
+                }
+                if (filters.teamId) {
+                    params = params.set('team_id', filters.teamId.toString());
+                }
+                if (filters.tournamentStageId) {
+                    params = params.set('tournament_stage_id', filters.tournamentStageId.toString());
+                }
+                if (filters.playoffId) {
+                    params = params.set('playoff_id', filters.playoffId.toString());
+                }
+                if (filters.playoffStage) {
+                    params = params.set('playoff_stage', filters.playoffStage.toString());
+                }
+                if (filters.status) {
+                    params = params.set('status', GameStatuses[filters.status]);
+                }
+            }
+            return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament/${tournamentId}/game_media/`, { observe: 'response', params }).pipe(map(response => {
+                return {
+                    total: +response.headers.get('X-Page-Count'),
+                    data: Game.toFront(response.body)
+                };
+            })).toPromise();
+        });
+    }
+    getLeagueGameMedia(leagueId, page, size, filters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let params = new HttpParams().set('page', page.toString()).set('size', size.toString());
+            if (filters) {
+                if (filters.tournamentTour) {
+                    params = params.set('tournament_tour', filters.tournamentTour.toString());
+                }
+                if (filters.teamId) {
+                    params = params.set('team_id', filters.teamId.toString());
+                }
+                if (filters.tournamentStageId) {
+                    params = params.set('tournament_stage_id', filters.tournamentStageId.toString());
+                }
+                if (filters.playoffId) {
+                    params = params.set('playoff_id', filters.playoffId.toString());
+                }
+                if (filters.playoffStage) {
+                    params = params.set('playoff_stage', filters.playoffStage.toString());
+                }
+                if (filters.status) {
+                    params = params.set('status', GameStatuses[filters.status]);
+                }
+            }
+            return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/league/${leagueId}/game_media/`, { observe: 'response', params }).pipe(map(response => {
+                return {
+                    total: +response.headers.get('X-Page-Count'),
+                    data: Game.toFront(response.body)
+                };
+            })).toPromise();
+        });
+    }
+    getGameMediaById(gameId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/game_media/${gameId}/`).pipe(map(result => Game.toFront(result))).toPromise();
+        });
+    }
+    getGameMedia(gameId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_game/${gameId}/media/`).pipe(map(result => MediaItem.toFront(result))).toPromise();
+        });
+    }
+    createZip(mediaIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient
+                .post(`${this.configService.get('apiUrl')}/api/v1/media/zip/`, mediaIds, { responseType: 'blob' })
+                .toPromise();
+        });
+    }
+};
+MediaApi.ctorParameters = () => [
+    { type: HttpClient },
+    { type: ConfigService }
+];
+MediaApi.ɵprov = ɵɵdefineInjectable({ factory: function MediaApi_Factory() { return new MediaApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: MediaApi, providedIn: "root" });
+MediaApi = __decorate([
+    Injectable({ providedIn: 'root' })
+], MediaApi);
+
+var PollStatuses;
+(function (PollStatuses) {
+    PollStatuses[PollStatuses["open"] = 1] = "open";
+    PollStatuses[PollStatuses["closed"] = 2] = "closed";
+    PollStatuses[PollStatuses["archived"] = 3] = "archived";
+})(PollStatuses || (PollStatuses = {}));
+let PollVariant = class PollVariant extends BaseModel {
+    static toFront(data) { }
+    static toBack(data) { }
+};
+__decorate([
+    ToFrontHook
+], PollVariant, "toFront", null);
+__decorate([
+    ToBackHook
+], PollVariant, "toBack", null);
+PollVariant = __decorate([
+    ModelInstance({
+        mappingFields: {
+            uuid: 'uuid',
+            name: 'name'
+        }
+    })
+], PollVariant);
+let PollAnswer = class PollAnswer extends BaseModel {
+    static toFront(data) { }
+    static toBack(data) { }
+};
+__decorate([
+    ToFrontHook
+], PollAnswer, "toFront", null);
+__decorate([
+    ToBackHook
+], PollAnswer, "toBack", null);
+PollAnswer = __decorate([
+    ModelInstance({
+        mappingFields: {
+            id: 'id',
+            answer_uuid: 'answerUuid',
+            user: 'user',
+            poll_id: 'pollId',
+        },
+        relation: {
+            user: User
+        }
+    })
+], PollAnswer);
+let Poll = class Poll extends BaseModel {
+    constructor() {
+        super(...arguments);
+        this.variantsWithAnswers = [];
+    }
+    set variants(value) {
+        this._variants = value || [];
+        if (this._answers) {
+            this.calculateAnswersPercentage();
+        }
+    }
+    get variants() {
+        return this._variants;
+    }
+    set answers(value) {
+        this._answers = value || [];
+        if (this._variants) {
+            this.calculateAnswersPercentage();
+        }
+    }
+    get answers() {
+        return this._answers;
+    }
+    calculateAnswersPercentage() {
+        if (!this._answers.length) {
+            return;
+        }
+        const variants = this._variants.map(v => v.uuid);
+        const answersByVariant = this._answers.reduce((acc, item) => {
+            if (variants.indexOf(item.answerUuid) < 0) {
+                return acc;
+            }
+            if (!acc[item.answerUuid]) {
+                acc[item.answerUuid] = 0;
+            }
+            acc[item.answerUuid]++;
+            return acc;
+        }, {});
+        this.variantsWithAnswers = this._variants.map(item => ({
+            variant: item,
+            percent: answersByVariant[item.uuid] ? Math.round(100 * answersByVariant[item.uuid] / this._answers.length) : 0
+        }))
+            .sort((a, b) => a.percent > b.percent ? -1 : 1);
+    }
+    static toFront(data) { }
+    static toBack(data) { }
+};
+__decorate([
+    ToFrontHook
+], Poll, "toFront", null);
+__decorate([
+    ToBackHook
+], Poll, "toBack", null);
+Poll = __decorate([
+    ModelInstance({
+        mappingFields: {
+            id: 'id',
+            active: 'active',
+            status: 'status',
+            team_id: 'teamId',
+            name: 'name',
+            description: 'description',
+            variants: 'variants',
+            author: 'author',
+            answers: 'answers',
+            multiple_answer: 'multipleAnswer',
+            anonymous: 'anonymous',
+            created_at: 'createdAt'
+        },
+        relation: {
+            status: enumField(PollStatuses),
+            variants: PollVariant,
+            author: User,
+            answers: PollAnswer,
+            createdAt: DateTimeField,
+        }
+    })
+], Poll);
+
+let TeamInvite = class TeamInvite extends BaseModel {
+    static toFront(data) { }
+    static toBack(data) { }
+};
+__decorate([
+    ToFrontHook
+], TeamInvite, "toFront", null);
+__decorate([
+    ToBackHook
+], TeamInvite, "toBack", null);
+TeamInvite = __decorate([
+    ModelInstance({
+        mappingFields: {
+            id: 'id',
+            user_id: 'userId',
+            user: 'user',
+            team: 'team',
+            team_id: 'teamId',
+            user_accept: 'userAccept',
+            team_accept: 'teamAccept',
+            users_count: 'usersCount',
+            games_count: 'gamesCount',
+            won_games_count: 'wonGamesCount',
+            score_sum: 'scoreSum',
+            created_at: 'createdAt',
+            updated_at: 'updatedAt',
+        },
+        relation: {
+            user: User,
+            team: Team,
+            createdAt: DateTimeField,
+            updateAt: DateTimeField,
+        }
+    })
+], TeamInvite);
+
+var GameInviteStatus;
+(function (GameInviteStatus) {
+    GameInviteStatus[GameInviteStatus["accepted"] = 1] = "accepted";
+    GameInviteStatus[GameInviteStatus["declined"] = 2] = "declined";
+})(GameInviteStatus || (GameInviteStatus = {}));
+let GameInvite = class GameInvite extends BaseModel {
+    static toFront(data) { }
+    static toBack(data) { }
+};
+__decorate([
+    ToFrontHook
+], GameInvite, "toFront", null);
+__decorate([
+    ToBackHook
+], GameInvite, "toBack", null);
+GameInvite = __decorate([
+    ModelInstance({
+        mappingFields: {
+            id: 'id',
+            team_user: 'teamUser',
+            game_id: 'gameId',
+            game: 'game',
+            status: 'status',
+        },
+        relation: {
+            game: Game,
+            teamUser: TeamUser,
+            status: enumField(GameInviteStatus),
+        }
+    })
+], GameInvite);
+
+var TeamEventTypes;
+(function (TeamEventTypes) {
+    TeamEventTypes[TeamEventTypes["training"] = 1] = "training";
+    TeamEventTypes[TeamEventTypes["other"] = 2] = "other";
+})(TeamEventTypes || (TeamEventTypes = {}));
+
+const TeamEventTypeLocalization = {
+    [TeamEventTypes.training]: 'Тренировка',
+    [TeamEventTypes.other]: 'Другое'
+};
+
+let TeamEvent = class TeamEvent extends BaseModel {
+    get name() {
+        if (this.eventType === TeamEventTypes.other) {
+            return this.eventCustomName;
+        }
+        return TeamEventTypeLocalization[this.eventType];
+    }
+    get isClosed() {
+        return this.datetime.getTime() < new Date().getTime();
+    }
+    static toFront(data) { }
+    static toBack(data) { }
+};
+__decorate([
+    ToFrontHook
+], TeamEvent, "toFront", null);
+__decorate([
+    ToBackHook
+], TeamEvent, "toBack", null);
+TeamEvent = __decorate([
+    ModelInstance({
+        mappingFields: {
+            id: 'id',
+            team_id: 'teamId',
+            team: 'team',
+            event_type: 'eventType',
+            event_custom_name: 'eventCustomName',
+            description: 'description',
+            datetime: 'datetime',
+            location: 'location',
+        },
+        relation: {
+            eventType: enumField(TeamEventTypes),
+            team: Team,
+            datetime: DateTimeField,
+        }
+    })
+], TeamEvent);
+
+var TeamEventInviteStatuses;
+(function (TeamEventInviteStatuses) {
+    TeamEventInviteStatuses[TeamEventInviteStatuses["accepted"] = 1] = "accepted";
+    TeamEventInviteStatuses[TeamEventInviteStatuses["declined"] = 2] = "declined";
+})(TeamEventInviteStatuses || (TeamEventInviteStatuses = {}));
+let TeamEventInvite = class TeamEventInvite {
+    static toFront(data) { }
+    static toBack(data) { }
+};
+__decorate([
+    ToFrontHook
+], TeamEventInvite, "toFront", null);
+__decorate([
+    ToBackHook
+], TeamEventInvite, "toBack", null);
+TeamEventInvite = __decorate([
+    ModelInstance({
+        mappingFields: {
+            id: 'id',
+            team_event_id: 'teamEventId',
+            team_user_id: 'teamUserId',
+            status: 'status',
+        },
+        relation: {
+            status: enumField(TeamEventInviteStatuses)
+        }
+    })
+], TeamEventInvite);
+
+let TournamentTeamUserInvite = class TournamentTeamUserInvite extends BaseModel {
+    static toFront(data) { }
+    static toBack(data) { }
+};
+__decorate([
+    ToFrontHook
+], TournamentTeamUserInvite, "toFront", null);
+__decorate([
+    ToBackHook
+], TournamentTeamUserInvite, "toBack", null);
+TournamentTeamUserInvite = __decorate([
+    ModelInstance({
+        mappingFields: {
+            id: 'id',
+            tournament_team_invite_id: 'tournamentTeamInviteId',
+            tournament_team_id: 'tournamentTeamId',
+            team_user: 'teamUser',
+            accepted: 'accepted'
+        },
+        relation: {
+            teamUser: TeamUser
+        }
+    })
+], TournamentTeamUserInvite);
+
+let TournamentInvite = class TournamentInvite extends BaseModel {
+    get isOpen() {
+        return (this.teamAccept === null || this.organizationAccept === null) && this.teamAccept !== false && this.organizationAccept !== false;
+    }
+    static toFront(data) { }
+    static toBack(data) { }
+};
+__decorate([
+    ToFrontHook
+], TournamentInvite, "toFront", null);
+__decorate([
+    ToBackHook
+], TournamentInvite, "toBack", null);
+TournamentInvite = __decorate([
+    ModelInstance({
+        mappingFields: {
+            id: 'id',
+            team: 'team',
+            tournament: 'tournament',
+            team_accept: 'teamAccept',
+            organization_accept: 'organizationAccept',
+            user_invites_count: 'userInvitesCount',
+            user_invites: 'userInvites',
+            notifications_count: 'notificationsCount',
+        },
+        relation: {
+            team: Team,
+            tournament: Tournament,
+            userInvites: TournamentTeamUserInvite,
+        }
+    })
+], TournamentInvite);
+
+var NotificationType;
+(function (NotificationType) {
+    NotificationType[NotificationType["team_updated"] = 1] = "team_updated";
+    NotificationType[NotificationType["team_invited"] = 2] = "team_invited";
+    NotificationType[NotificationType["team_join_request"] = 3] = "team_join_request";
+    NotificationType[NotificationType["team_join_declined_by_team"] = 4] = "team_join_declined_by_team";
+    NotificationType[NotificationType["team_join_declined_by_user"] = 5] = "team_join_declined_by_user";
+    NotificationType[NotificationType["team_join_canceled_by_team"] = 6] = "team_join_canceled_by_team";
+    NotificationType[NotificationType["team_join_canceled_by_user"] = 7] = "team_join_canceled_by_user";
+    NotificationType[NotificationType["team_joined_for_user"] = 8] = "team_joined_for_user";
+    NotificationType[NotificationType["team_joined_for_team"] = 9] = "team_joined_for_team";
+    NotificationType[NotificationType["team_user_role_changed_for_user"] = 10] = "team_user_role_changed_for_user";
+    NotificationType[NotificationType["team_user_role_changed_for_team"] = 11] = "team_user_role_changed_for_team";
+    NotificationType[NotificationType["team_user_number_changed"] = 12] = "team_user_number_changed";
+    NotificationType[NotificationType["team_user_deleted_for_user"] = 13] = "team_user_deleted_for_user";
+    NotificationType[NotificationType["team_user_deleted_for_team"] = 14] = "team_user_deleted_for_team";
+    NotificationType[NotificationType["team_user_left"] = 15] = "team_user_left";
+    NotificationType[NotificationType["game_updated"] = 16] = "game_updated";
+    NotificationType[NotificationType["game_invited"] = 17] = "game_invited";
+    NotificationType[NotificationType["game_invite_accepted"] = 18] = "game_invite_accepted";
+    NotificationType[NotificationType["game_invite_declined"] = 19] = "game_invite_declined";
+    NotificationType[NotificationType["game_remind"] = 20] = "game_remind";
+    NotificationType[NotificationType["game_won"] = 21] = "game_won";
+    NotificationType[NotificationType["game_losing"] = 22] = "game_losing";
+    NotificationType[NotificationType["game_tech_defeat"] = 23] = "game_tech_defeat";
+    NotificationType[NotificationType["game_tech_victory"] = 24] = "game_tech_victory";
+    NotificationType[NotificationType["poll_created"] = 25] = "poll_created";
+    NotificationType[NotificationType["poll_closed"] = 26] = "poll_closed";
+    NotificationType[NotificationType["team_event_invited"] = 27] = "team_event_invited";
+    NotificationType[NotificationType["team_event_accepted"] = 28] = "team_event_accepted";
+    NotificationType[NotificationType["team_event_declined"] = 29] = "team_event_declined";
+    NotificationType[NotificationType["team_event_remind"] = 30] = "team_event_remind";
+    NotificationType[NotificationType["tournament_invited"] = 31] = "tournament_invited";
+    NotificationType[NotificationType["tournament_joined"] = 32] = "tournament_joined";
+    NotificationType[NotificationType["tournament_join_declined"] = 33] = "tournament_join_declined";
+    NotificationType[NotificationType["tournament_join_canceled"] = 34] = "tournament_join_canceled";
+    NotificationType[NotificationType["tournament_user_invited"] = 35] = "tournament_user_invited";
+    NotificationType[NotificationType["tournament_user_accepted_for_team"] = 36] = "tournament_user_accepted_for_team";
+    NotificationType[NotificationType["tournament_user_accepted_for_user"] = 37] = "tournament_user_accepted_for_user";
+    NotificationType[NotificationType["tournament_user_added"] = 38] = "tournament_user_added";
+    NotificationType[NotificationType["tournament_user_declined_for_team"] = 39] = "tournament_user_declined_for_team";
+    NotificationType[NotificationType["tournament_user_declined_for_user"] = 40] = "tournament_user_declined_for_user";
+    NotificationType[NotificationType["tournament_user_invite_deleted"] = 41] = "tournament_user_invite_deleted";
+    NotificationType[NotificationType["tournament_user_deleted"] = 42] = "tournament_user_deleted";
+    NotificationType[NotificationType["tournament_user_disqualified_for_team"] = 43] = "tournament_user_disqualified_for_team";
+    NotificationType[NotificationType["tournament_user_disqualified_for_user"] = 44] = "tournament_user_disqualified_for_user";
+    NotificationType[NotificationType["tournament_user_disqualification_updated_for_team"] = 45] = "tournament_user_disqualification_updated_for_team";
+    NotificationType[NotificationType["tournament_user_disqualification_updated_for_user"] = 46] = "tournament_user_disqualification_updated_for_user";
+    NotificationType[NotificationType["tournament_team_deleted"] = 47] = "tournament_team_deleted";
+    NotificationType[NotificationType["org_tournament_invite_created"] = 48] = "org_tournament_invite_created";
+    NotificationType[NotificationType["org_tournament_invite_declined"] = 49] = "org_tournament_invite_declined";
+    NotificationType[NotificationType["org_tournament_invite_deleted"] = 50] = "org_tournament_invite_deleted";
+    NotificationType[NotificationType["org_tournament_invite_changed"] = 51] = "org_tournament_invite_changed";
+    NotificationType[NotificationType["org_tournament_user_deleted"] = 52] = "org_tournament_user_deleted";
+    NotificationType[NotificationType["org_tournament_user_invited"] = 53] = "org_tournament_user_invited";
+    NotificationType[NotificationType["org_tournament_user_has_changes"] = 54] = "org_tournament_user_has_changes";
+    NotificationType[NotificationType["org_tournament_team_leave"] = 55] = "org_tournament_team_leave";
+})(NotificationType || (NotificationType = {}));
+var NotificationServiceEnum;
+(function (NotificationServiceEnum) {
+    NotificationServiceEnum[NotificationServiceEnum["public"] = 1] = "public";
+    NotificationServiceEnum[NotificationServiceEnum["org"] = 2] = "org";
+})(NotificationServiceEnum || (NotificationServiceEnum = {}));
+let Notification = class Notification extends BaseModel {
+    get important() {
+        return true;
+    }
+    static toFront(value) { }
+    static toBack(value) { }
+};
+__decorate([
+    ToFrontHook
+], Notification, "toFront", null);
+__decorate([
+    ToBackHook
+], Notification, "toBack", null);
+Notification = __decorate([
+    ModelInstance({
+        mappingFields: {
+            id: 'id',
+            event_type: 'event',
+            data: 'data',
+            initiator: 'initiator',
+            team: 'team',
+            team_invite: 'teamInvite',
+            team_user: 'teamUser',
+            poll: 'poll',
+            game: 'game',
+            game_invite: 'gameInvite',
+            team_event: 'teamEvent',
+            team_event_invite: 'teamEventInvite',
+            tournament: 'tournament',
+            tournament_invite: 'tournamentInvite',
+            tournament_team: 'tournamentTeam',
+            viewed: 'viewed',
+            protected: 'protected',
+            service: 'service',
+            created_at: 'createdAt',
+        },
+        relation: {
+            event: enumField(NotificationType),
+            initiator: User,
+            team: Team,
+            teamInvite: TeamInvite,
+            teamUser: TeamUser,
+            poll: Poll,
+            game: Game,
+            gameInvite: GameInvite,
+            teamEvent: TeamEvent,
+            teamEventInvite: TeamEventInvite,
+            tournament: Tournament,
+            tournamentInvite: TournamentInvite,
+            tournamentTeam: TournamentTeam,
+            service: enumField(NotificationServiceEnum),
+            createdAt: DateTimeField,
+        }
+    })
+], Notification);
+
+var NotificationAllowTypes;
+(function (NotificationAllowTypes) {
+    NotificationAllowTypes[NotificationAllowTypes["all"] = 1] = "all";
+    NotificationAllowTypes[NotificationAllowTypes["important"] = 2] = "important";
+    NotificationAllowTypes[NotificationAllowTypes["none"] = 3] = "none";
+})(NotificationAllowTypes || (NotificationAllowTypes = {}));
+let NotificationSettings = class NotificationSettings extends BaseModel {
+    static toFront(data) { }
+    static toBack(data) { }
+};
+__decorate([
+    ToFrontHook
+], NotificationSettings, "toFront", null);
+__decorate([
+    ToBackHook
+], NotificationSettings, "toBack", null);
+NotificationSettings = __decorate([
+    ModelInstance({
+        mappingFields: {
+            user_id: 'userId',
+            popup: 'popup',
+            sound: 'sound',
+            browser: 'browser',
+            email: 'email'
+        },
+        relation: {
+            sound: enumField(NotificationAllowTypes),
+            browser: enumField(NotificationAllowTypes),
+        }
+    })
+], NotificationSettings);
+
+let NotificationBaseApi = class NotificationBaseApi {
+    constructor(httpClient, configService) {
+        this.httpClient = httpClient;
+        this.configService = configService;
+    }
+    getCount() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient
+                .get(`${this.configService.get('apiUrl')}${this.apiUrl}/notification/count/`)
+                .pipe(map(data => +data))
+                .toPromise();
+        });
+    }
+    getList(page, size, filters = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let params = new HttpParams()
+                .set('page', page.toString())
+                .set('size', size.toString());
+            for (const key of Object.keys(filters)) {
+                params = params.set(key, filters[key]);
+            }
+            return this.httpClient
+                .get(`${this.configService.get('apiUrl')}${this.apiUrl}/notification/`, { params, observe: 'response' })
+                .pipe(map(response => {
+                const data = Notification.toFront(response.body);
+                return {
+                    total: +response.headers.get('x-page-count'),
+                    data
+                };
+            })).toPromise();
+        });
+    }
+    markViewed(notificationId, viewed) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient
+                .post(`${this.configService.get('apiUrl')}${this.apiUrl}/notification/${notificationId}/viewed/`, { viewed })
+                .pipe(map(data => Notification.toFront(data)))
+                .toPromise();
+        });
+    }
+    markAllViewed() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient
+                .post(`${this.configService.get('apiUrl')}${this.apiUrl}/notification/viewed/`, {})
+                .pipe(map(data => Notification.toFront(data)))
+                .toPromise();
+        });
+    }
+    getNotificationSettings() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`${this.configService.get('apiUrl')}${this.apiUrl}/notification_settings/`)
+                .pipe(map(data => NotificationSettings.toFront(data)))
+                .toPromise();
+        });
+    }
+    updateNotificationSettings(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.post(`${this.configService.get('apiUrl')}${this.apiUrl}/notification_settings/`, NotificationSettings.toBack(data))
+                .pipe(map(result => NotificationSettings.toFront(result)))
+                .toPromise();
+        });
+    }
+};
+NotificationBaseApi.ctorParameters = () => [
+    { type: HttpClient },
+    { type: ConfigService }
+];
+NotificationBaseApi.ɵprov = ɵɵdefineInjectable({ factory: function NotificationBaseApi_Factory() { return new NotificationBaseApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: NotificationBaseApi, providedIn: "root" });
+NotificationBaseApi = __decorate([
+    Injectable({ providedIn: 'root' })
+], NotificationBaseApi);
+
+let NotificationApi = class NotificationApi extends NotificationBaseApi {
+    constructor() {
+        super(...arguments);
+        this.apiUrl = '/api/v1';
+    }
+};
+NotificationApi.ɵprov = ɵɵdefineInjectable({ factory: function NotificationApi_Factory() { return new NotificationApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: NotificationApi, providedIn: "root" });
+NotificationApi = __decorate([
+    Injectable({ providedIn: 'root' })
+], NotificationApi);
+
+let OrgNotificationApi = class OrgNotificationApi extends NotificationBaseApi {
+    constructor() {
+        super(...arguments);
+        this.apiUrl = '/org/api/v1';
+    }
+};
+OrgNotificationApi.ɵprov = ɵɵdefineInjectable({ factory: function OrgNotificationApi_Factory() { return new OrgNotificationApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: OrgNotificationApi, providedIn: "root" });
+OrgNotificationApi = __decorate([
+    Injectable({ providedIn: 'root' })
+], OrgNotificationApi);
+
+let ReferenceApi = class ReferenceApi {
+    constructor(httpClient, configService) {
+        this.httpClient = httpClient;
+        this.configService = configService;
+    }
+    getCities() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient
+                .get(`${this.configService.get('apiUrl')}/api/v1/reference/cities/`)
+                .pipe(map(data => City.toFront(data))).toPromise();
+        });
+    }
+    getSports() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient
+                .get(`${this.configService.get('apiUrl')}/api/v1/sport/`)
+                .pipe(map(data => Sport.toFront(data))).toPromise();
+        });
+    }
+};
+ReferenceApi.ctorParameters = () => [
+    { type: HttpClient },
+    { type: ConfigService }
+];
+ReferenceApi.ɵprov = ɵɵdefineInjectable({ factory: function ReferenceApi_Factory() { return new ReferenceApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: ReferenceApi, providedIn: "root" });
+ReferenceApi = __decorate([
+    Injectable({ providedIn: 'root' })
+], ReferenceApi);
+
+let TournamentNews = class TournamentNews extends BaseModel {
+    static toFront(data) { }
+    static toBack(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);
+
+let GameTimelineStageItem = class GameTimelineStageItem {
+    static toFront(data) { }
+    static toBack(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);
+let GameTimelineStages = class GameTimelineStages extends BaseModel {
+    static toFront(data) { }
+    static toBack(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);
+
+var TournamentStageStatuses;
+(function (TournamentStageStatuses) {
+    TournamentStageStatuses[TournamentStageStatuses["open"] = 0] = "open";
+    TournamentStageStatuses[TournamentStageStatuses["in_progress"] = 1] = "in_progress";
+    TournamentStageStatuses[TournamentStageStatuses["closed"] = 2] = "closed";
+})(TournamentStageStatuses || (TournamentStageStatuses = {}));
+let TournamentStage = class TournamentStage extends BaseModel {
+    static toFront(data) { }
+    static toBack(data) { }
+};
+__decorate([
+    ToFrontHook
+], TournamentStage, "toFront", null);
+__decorate([
+    ToBackHook
+], TournamentStage, "toBack", null);
+TournamentStage = __decorate([
+    ModelInstance({
+        mappingFields: {
+            id: 'id',
+            name: 'name',
+            date: 'date',
+            tournament_id: 'tournamentId',
+            status: 'status',
+        },
+        relation: {
+            date: DateField,
+            status: enumField(TournamentStageStatuses)
+        }
+    })
+], TournamentStage);
+
+function generateArray(length) {
+    if (length <= 0) {
+        return [];
+    }
+    return Array.apply(null, Array(length)).map((_, i) => i + 1);
+}
+function getArrayChunks(array, length) {
+    const chunks = [];
+    const chunkLength = Math.ceil(array.length / length);
+    if (chunkLength === 0) {
+        return [array];
+    }
+    for (let i = 0; i < chunkLength; i++) {
+        chunks.push(array.slice(i * length, (i + 1) * length));
+    }
+    return chunks;
+}
+
+let PlayoffSettings = class PlayoffSettings extends BaseModel {
+    static toFront(data) { }
+    static toBack(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);
+let Playoff = class Playoff extends BaseModel {
+    constructor() {
+        super(...arguments);
+        this.stages = [];
+    }
+    static toFront(data) { }
+    static toBack(data) { }
+    get stagesCount() {
+        return Math.log(this.settings.teamsCount) / Math.log(2);
+    }
+    getPlayoffStages() {
+        if (this.stages.length === 0 && this.settings.teamsCount) {
+            const stagesCount = Math.log(this.settings.teamsCount) / Math.log(2);
+            this.stages = generateArray(stagesCount).map(stage => {
+                const playoffStage = this.settings.teamsCount / Math.pow(2, stage);
+                let title = '';
+                if (playoffStage === 1) {
+                    title = 'Финал';
+                }
+                else {
+                    title = `1 / ${playoffStage}`;
+                }
+                return {
+                    value: stage,
+                    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);
+
+let VolleyballStatistic = class VolleyballStatistic extends BaseModel {
+    static toFront(data) { }
+    static toBack(data) { }
+};
+__decorate([
+    ToFrontHook
+], VolleyballStatistic, "toFront", null);
+__decorate([
+    ToBackHook
+], VolleyballStatistic, "toBack", null);
+VolleyballStatistic = __decorate([
+    ModelInstance({
+        mappingFields: {
+            team: 'team',
+            team_user: 'teamUser',
+            tournament_team_user: 'tournamentTeamUser',
+            tournament_team: 'tournamentTeam',
+            user: 'user',
+            month: 'month',
+            win_lose: 'winLose',
+            games_count: 'gamesCount',
+            won_games_count: 'wonGamesCount',
+            serve_hits: 'serveHits',
+            serve_faults: 'serveFaults',
+            serve_aces: 'serveAces',
+            serve_percent: 'servePercent',
+            ace_percent: 'acePercent',
+            stuff_blocks: 'stuffBlocks',
+            block_faults: 'blockFaults',
+            block_rebounds: 'blockRebounds',
+            block_percent: 'blockPercent',
+            attack_spikes: 'attackSpikes',
+            attack_faults: 'attackFaults',
+            attack_shots: 'attackShots',
+            attack_percent: 'attackPercent',
+            receives: 'receives',
+            receive_faults: 'receiveFaults',
+            excellent_receives: 'excellentReceives',
+            receive_percent: 'receivePercent',
+            serve_receives: 'serveReceives',
+            serve_receive_faults: 'serveReceiveFaults',
+            excellent_serve_receives: 'excellentServeReceives',
+            serve_receive_percent: 'serveReceivePercent',
+            points: 'points',
+            faults: 'faults',
+            newbie: 'newbie',
+        },
+        relation: {
+            team: Team,
+            teamUser: TeamUser,
+            tournamentTeamUser: TournamentTeamUser,
+            tournamentTeam: TournamentTeam,
+            user: User,
+            month: DateField,
+        }
+    })
+], VolleyballStatistic);
+
+let TournamentStageTeam = class TournamentStageTeam extends BaseModel {
+    get gamesWonPercent() {
+        if (!this.gamesCount) {
+            return 0;
+        }
+        return Math.floor(1000 * this.wonGamesCount / this.gamesCount) / 10;
+    }
+    static toFront(data) { }
+    static toBack(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);
+
+let TournamentApi = class TournamentApi {
+    constructor(httpClient, configService) {
+        this.httpClient = httpClient;
+        this.configService = configService;
+    }
+    getByAlias(alias) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament/${alias}/`)
+                .pipe(map(result => Tournament.toFront(result)))
+                .toPromise();
+        });
+    }
+    getNews(tournamentId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament/${tournamentId}/news/`)
+                .pipe(map(result => TournamentNews.toFront(result)))
+                .toPromise();
+        });
+    }
+    getEvents(tournamentId, page, size, filters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let 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 this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament/${tournamentId}/events/`, { params, observe: 'response' })
+                .pipe(map(result => ({
+                total: +result.headers.get('X-Page-Count'),
+                data: TournamentEvent.toFront(result.body)
+            })))
+                .toPromise();
+        });
+    }
+    getTournamentStages(tournamentId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament/${tournamentId}/stages/`).pipe(map(data => TournamentStage.toFront(data))).toPromise();
+        });
+    }
+    getPlayoff(tournamentId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament/${tournamentId}/playoff/`).pipe(map(result => Playoff.toFront(result))).toPromise();
+        });
+    }
+    getPlayoffGames(playoffId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_playoff/${playoffId}/games/`).pipe(map(result => Game.toFront(result))).toPromise();
+        });
+    }
+    getGamesStages(tournamentId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament/${tournamentId}/games_stages/`)
+                .pipe(map(data => GameTimelineStages.toFront(data)))
+                .toPromise();
+        });
+    }
+    getGames(tournamentId, page, size, filters = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let 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 this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament/${tournamentId}/games/`, { params, observe: 'response' })
+                .pipe(map(result => ({
+                total: +result.headers.get('X-Page-Count'),
+                data: Game.toFront(result.body)
+            }))).toPromise();
+        });
+    }
+    getTeams(tournamentId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament/${tournamentId}/teams/`)
+                .pipe(map(result => TournamentTeam.toFront(result)))
+                .toPromise();
+        });
+    }
+    getStageTeams(tournamentId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament/${tournamentId}/stage_teams/`)
+                .pipe(map(result => TournamentStageTeam.toFront(result)))
+                .toPromise();
+        });
+    }
+    getTeamById(tournamentTeamId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_team/${tournamentTeamId}/`)
+                .pipe(map(result => TournamentTeam.toFront(result)))
+                .toPromise();
+        });
+    }
+    getUserById(userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_team_user/${userId}/`)
+                .pipe(map(result => TournamentTeamUser.toFront(result)))
+                .toPromise();
+        });
+    }
+    getUserGames(tournamentUserId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_team_user/${tournamentUserId}/games/`)
+                .pipe(map(result => Game.toFront(result)))
+                .toPromise();
+        });
+    }
+    getBasketballStatistic(filters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let params = new HttpParams();
+            if (filters) {
+                for (const key of Object.keys(filters)) {
+                    if (filters[key]) {
+                        params = params.set(key, filters[key]);
+                    }
+                }
+                if (filters.per_game !== undefined) {
+                    params = params.set('per_game', filters.per_game ? '1' : '0');
+                }
+            }
+            return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/basketball_statistic/`, { params }).pipe(map(result => BasketballStatistic.toFront(result))).toPromise();
+        });
+    }
+    getVolleyballStatistic(filters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let params = new HttpParams();
+            if (filters) {
+                for (const key of Object.keys(filters)) {
+                    if (filters[key]) {
+                        params = params.set(key, filters[key]);
+                    }
+                }
+                if (filters.per_game !== undefined) {
+                    params = params.set('per_game', filters.per_game ? '1' : '0');
+                }
+            }
+            return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/volleyball_statistic/`, { params }).pipe(map(result => VolleyballStatistic.toFront(result))).toPromise();
+        });
+    }
+};
+TournamentApi.ctorParameters = () => [
+    { type: HttpClient },
+    { type: ConfigService }
+];
+TournamentApi.ɵprov = ɵɵdefineInjectable({ factory: function TournamentApi_Factory() { return new TournamentApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: TournamentApi, providedIn: "root" });
+TournamentApi = __decorate([
+    Injectable({ providedIn: 'root' })
+], TournamentApi);
+
+let TournamentJoinData = class TournamentJoinData extends BaseModel {
+    get usersCount() {
+        return this.validUsersCount + this.invalidUsersCount;
+    }
+    get valid() {
+        return this.hasAccess && !this.inviteSent && !this.alreadyInTournament;
+    }
+    static toFront(data) { }
+    static toBack(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);
+let TournamentJoinTeam = class TournamentJoinTeam extends BaseModel {
+    static toFront(data) { }
+    static toBack(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);
+
+let TournamentJoinApi = class TournamentJoinApi {
+    constructor(httpClient, configService) {
+        this.httpClient = httpClient;
+        this.configService = configService;
+    }
+    getTeamsForJoin(tournamentId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament/${tournamentId}/teams_for_join/`).pipe(map(response => TournamentJoinTeam.toFront(response))).toPromise();
+        });
+    }
+    getTeamUsers(teamId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient
+                .get(`${this.configService.get('apiUrl')}/api/v1/team/${teamId}/users/`)
+                .pipe(map(data => TeamUser.toFront(data))).toPromise();
+        });
+    }
+    joinTournament(tournamentId, teamId, invites) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const body = {
+                team: { id: teamId },
+                user_invites: TournamentTeamUserInvite.toBack(invites)
+            };
+            return this.httpClient.post(`${this.configService.get('apiUrl')}/api/v1/tournament/${tournamentId}/join/`, body)
+                .pipe(map(data => TournamentInvite.toFront(data)))
+                .toPromise();
+        });
+    }
+};
+TournamentJoinApi.ctorParameters = () => [
+    { type: HttpClient },
+    { type: ConfigService }
+];
+TournamentJoinApi.ɵprov = ɵɵdefineInjectable({ factory: function TournamentJoinApi_Factory() { return new TournamentJoinApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: TournamentJoinApi, providedIn: "root" });
+TournamentJoinApi = __decorate([
+    Injectable({ providedIn: 'root' })
+], TournamentJoinApi);
+
+let TournamentStageApi = class TournamentStageApi {
+    constructor(httpClient, configService) {
+        this.httpClient = httpClient;
+        this.configService = configService;
+    }
+    getById(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_stage/${id}/`)
+                .pipe(map(result => TournamentStage.toFront(result)))
+                .toPromise();
+        });
+    }
+    getGroups(stageId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_stage/${stageId}/groups/`)
+                .pipe(map(result => TournamentGroup.toFront(result)))
+                .toPromise();
+        });
+    }
+    getPlayoffs(stageId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_stage/${stageId}/playoff/`)
+                .pipe(map(result => Playoff.toFront(result)))
+                .toPromise();
+        });
+    }
+    getTeams(stageId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_stage/${stageId}/teams/`)
+                .pipe(map(result => TournamentStageTeam.toFront(result)))
+                .toPromise();
+        });
+    }
+};
+TournamentStageApi.ctorParameters = () => [
+    { type: HttpClient },
+    { type: ConfigService }
+];
+TournamentStageApi.ɵprov = ɵɵdefineInjectable({ factory: function TournamentStageApi_Factory() { return new TournamentStageApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: TournamentStageApi, providedIn: "root" });
+TournamentStageApi = __decorate([
+    Injectable({ providedIn: 'root' })
+], TournamentStageApi);
+
+let VolleyballGameTeamStatistic = class VolleyballGameTeamStatistic extends BaseModel {
+    static toFront(data) { }
+    static toBack(data) { }
+};
+__decorate([
+    ToFrontHook
+], VolleyballGameTeamStatistic, "toFront", null);
+__decorate([
+    ToBackHook
+], VolleyballGameTeamStatistic, "toBack", null);
+VolleyballGameTeamStatistic = __decorate([
+    ModelInstance({
+        mappingFields: {
+            team: 'team',
+            competitor_team: 'competitorTeam',
+        },
+        relation: {
+            team: VolleyballStatistic,
+            competitorTeam: VolleyballStatistic,
+        }
+    })
+], VolleyballGameTeamStatistic);
+
+let VolleyballGameStatistic = class VolleyballGameStatistic extends BaseModel {
+    get id() {
+        return this.gameUserId;
+    }
+    get attacks() {
+        return this.attackSpikes + this.attackShots;
+    }
+    get blocks() {
+        return this.stuffBlocks + this.blockRebounds;
+    }
+    get totalReceives() {
+        return this.receives + this.excellentReceives;
+    }
+    static toFront(data) { }
+    static toBack(data) { }
+};
+__decorate([
+    ToFrontHook
+], VolleyballGameStatistic, "toFront", null);
+__decorate([
+    ToBackHook
+], VolleyballGameStatistic, "toBack", null);
+VolleyballGameStatistic = __decorate([
+    ModelInstance({
+        mappingFields: {
+            game_user_id: 'gameUserId',
+            serve_hits: 'serveHits',
+            serve_faults: 'serveFaults',
+            serve_aces: 'serveAces',
+            stuff_blocks: 'stuffBlocks',
+            block_faults: 'blockFaults',
+            block_rebounds: 'blockRebounds',
+            attack_spikes: 'attackSpikes',
+            attack_faults: 'attackFaults',
+            attack_shots: 'attackShots',
+            receives: 'receives',
+            receive_faults: 'receiveFaults',
+            excellent_receives: 'excellentReceives',
+            serve_receives: 'serveReceives',
+            serve_receive_faults: 'serveReceiveFaults',
+            excellent_serve_receives: 'excellentServeReceives',
+            points: 'points',
+            faults: 'faults',
+        }
+    })
+], VolleyballGameStatistic);
+
+var VolleyballGameLogType;
+(function (VolleyballGameLogType) {
+    VolleyballGameLogType[VolleyballGameLogType["enter_game"] = 1] = "enter_game";
+    VolleyballGameLogType[VolleyballGameLogType["exit_game"] = 2] = "exit_game";
+    VolleyballGameLogType[VolleyballGameLogType["remove_game"] = 3] = "remove_game";
+    VolleyballGameLogType[VolleyballGameLogType["serve_hit"] = 4] = "serve_hit";
+    VolleyballGameLogType[VolleyballGameLogType["serve_fault"] = 5] = "serve_fault";
+    VolleyballGameLogType[VolleyballGameLogType["serve_ace"] = 6] = "serve_ace";
+    VolleyballGameLogType[VolleyballGameLogType["stuff_block"] = 7] = "stuff_block";
+    VolleyballGameLogType[VolleyballGameLogType["block_fault"] = 8] = "block_fault";
+    VolleyballGameLogType[VolleyballGameLogType["block_rebound"] = 9] = "block_rebound";
+    VolleyballGameLogType[VolleyballGameLogType["attack_spike"] = 10] = "attack_spike";
+    VolleyballGameLogType[VolleyballGameLogType["attack_fault"] = 11] = "attack_fault";
+    VolleyballGameLogType[VolleyballGameLogType["attack_shot"] = 12] = "attack_shot";
+    VolleyballGameLogType[VolleyballGameLogType["receive"] = 13] = "receive";
+    VolleyballGameLogType[VolleyballGameLogType["receive_fault"] = 14] = "receive_fault";
+    VolleyballGameLogType[VolleyballGameLogType["excellent_receive"] = 15] = "excellent_receive";
+    VolleyballGameLogType[VolleyballGameLogType["point"] = 16] = "point";
+    VolleyballGameLogType[VolleyballGameLogType["fault"] = 17] = "fault";
+    VolleyballGameLogType[VolleyballGameLogType["serve_receive"] = 18] = "serve_receive";
+    VolleyballGameLogType[VolleyballGameLogType["serve_receive_fault"] = 19] = "serve_receive_fault";
+    VolleyballGameLogType[VolleyballGameLogType["excellent_serve_receive"] = 20] = "excellent_serve_receive";
+    VolleyballGameLogType[VolleyballGameLogType["timeout"] = 21] = "timeout";
+})(VolleyballGameLogType || (VolleyballGameLogType = {}));
+const SCORE_LOG_TYPES = [
+    VolleyballGameLogType.serve_ace, VolleyballGameLogType.stuff_block,
+    VolleyballGameLogType.attack_spike, VolleyballGameLogType.point
+];
+const FAULT_LOG_TYPES = [
+    VolleyballGameLogType.serve_fault, VolleyballGameLogType.attack_fault,
+    VolleyballGameLogType.block_fault, VolleyballGameLogType.receive_fault,
+    VolleyballGameLogType.fault, VolleyballGameLogType.serve_receive_fault
+];
+let VolleyballGameLog = class VolleyballGameLog extends BaseModel {
+    constructor() {
+        super(...arguments);
+        this.active = true;
+    }
+    compare(model) {
+        if (this.rally === model.rally && this.set === model.set) {
+            if (this.datetime && model.datetime) {
+                return this.datetime.getTime() < model.datetime.getTime() ? 1 : -1;
+            }
+            else {
+                return this.id < model.id ? 1 : -1;
+            }
+        }
+        if (this.set === model.set) {
+            return this.rally < model.rally ? 1 : -1;
+        }
+        return this.set < model.set ? 1 : -1;
+    }
+    isScoreType() {
+        return SCORE_LOG_TYPES.includes(this.logType);
+    }
+    isFaultType() {
+        return FAULT_LOG_TYPES.includes(this.logType);
+    }
+    isServe() {
+        return [
+            VolleyballGameLogType.serve_hit,
+            VolleyballGameLogType.serve_ace,
+            VolleyballGameLogType.serve_fault
+        ].includes(this.logType);
+    }
+    isAttack() {
+        return [
+            VolleyballGameLogType.attack_fault,
+            VolleyballGameLogType.attack_spike,
+            VolleyballGameLogType.attack_shot
+        ].includes(this.logType);
+    }
+    isReceive() {
+        return [
+            VolleyballGameLogType.receive_fault,
+            VolleyballGameLogType.receive,
+            VolleyballGameLogType.excellent_receive
+        ].includes(this.logType);
+    }
+    isServeReceive() {
+        return [
+            VolleyballGameLogType.serve_receive_fault,
+            VolleyballGameLogType.serve_receive,
+            VolleyballGameLogType.excellent_serve_receive
+        ].includes(this.logType);
+    }
+    isBlock() {
+        return [
+            VolleyballGameLogType.block_fault,
+            VolleyballGameLogType.block_rebound,
+            VolleyballGameLogType.stuff_block
+        ].includes(this.logType);
+    }
+    isEnterExit() {
+        return [
+            VolleyballGameLogType.enter_game,
+            VolleyballGameLogType.exit_game,
+            VolleyballGameLogType.timeout
+        ].includes(this.logType);
+    }
+    isComboType() {
+        return ![
+            VolleyballGameLogType.receive,
+            VolleyballGameLogType.serve_receive
+        ].includes(this.logType);
+    }
+    static toFront(data) { }
+    static toBack(data) { }
+};
+__decorate([
+    ToFrontHook
+], VolleyballGameLog, "toFront", null);
+__decorate([
+    ToBackHook
+], VolleyballGameLog, "toBack", null);
+VolleyballGameLog = __decorate([
+    ModelInstance({
+        mappingFields: {
+            id: 'id',
+            unique_id: 'uniqueId',
+            game_id: 'gameId',
+            game_user_id: 'gameUserId',
+            log_type: 'logType',
+            set: 'set',
+            rally: 'rally',
+            position: 'position',
+            team_id: 'teamId',
+            datetime: 'datetime',
+        },
+        relation: {
+            logType: enumField(VolleyballGameLogType),
+            datetime: DateTimeField
+        }
+    })
+], VolleyballGameLog);
+
+let VolleyballGameApi = class VolleyballGameApi {
+    constructor(httpClient, configService) {
+        this.httpClient = httpClient;
+        this.configService = configService;
+    }
+    getById(gameId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_volleyball_game/${gameId}/`).pipe(map(result => Game.toFront(result))).toPromise();
+        });
+    }
+    getUsers(gameId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_game/${gameId}/users/`).pipe(map(result => GameUser.toFront(result))).toPromise();
+        });
+    }
+    getTeamStatistic(gameId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_volleyball_game/${gameId}/team_statistic/`).pipe(map(result => VolleyballGameTeamStatistic.toFront(result))).toPromise();
+        });
+    }
+    getUserStatistic(gameId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_volleyball_game/${gameId}/user_statistic/`).pipe(map(result => VolleyballGameStatistic.toFront(result))).toPromise();
+        });
+    }
+    getLogs(gameId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_volleyball_game/${gameId}/logs/`).pipe(map(result => VolleyballGameLog.toFront(result))).toPromise();
+        });
+    }
+};
+VolleyballGameApi.ctorParameters = () => [
+    { type: HttpClient },
+    { type: ConfigService }
+];
+VolleyballGameApi.ɵprov = ɵɵdefineInjectable({ factory: function VolleyballGameApi_Factory() { return new VolleyballGameApi(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: VolleyballGameApi, providedIn: "root" });
+VolleyballGameApi = __decorate([
+    Injectable({ providedIn: 'root' })
+], VolleyballGameApi);
+
+const BasketballGameLogTypeLocalization = {
+    [BasketballGameLogTypes.enter_game]: 'Выход на площадку',
+    [BasketballGameLogTypes.exit_game]: 'Ушел с площадки',
+    [BasketballGameLogTypes.remove_game]: 'Удаление с площадки',
+    [BasketballGameLogTypes.two_point_attempt]: 'Бросок 2 очка',
+    [BasketballGameLogTypes.three_point_attempt]: 'Бросок 3 очка',
+    [BasketballGameLogTypes.free_throw_attempt]: 'Штрафной бросок',
+    [BasketballGameLogTypes.one_point_attempt]: 'Бросок 1 очко',
+    [BasketballGameLogTypes.two_point_made]: '2 очка',
+    [BasketballGameLogTypes.three_point_made]: '3 очка',
+    [BasketballGameLogTypes.free_throw_made]: '1 очко, штрафной',
+    [BasketballGameLogTypes.one_point_made]: '1 очко',
+    [BasketballGameLogTypes.assist]: 'Передача',
+    [BasketballGameLogTypes.block]: 'Блокшот',
+    [BasketballGameLogTypes.rebound]: 'Подбор',
+    [BasketballGameLogTypes.offensive_rebound]: 'Подбор в нападении',
+    [BasketballGameLogTypes.defensive_rebound]: 'Подбор в защите',
+    [BasketballGameLogTypes.steal]: 'Перехват',
+    [BasketballGameLogTypes.turnover]: 'Потеря',
+    [BasketballGameLogTypes.personal_foul]: 'Фол',
+    [BasketballGameLogTypes.technical_foul]: 'Технический фол',
+    [BasketballGameLogTypes.unsportsmanlike_foul]: 'Неспортиный фол',
+    [BasketballGameLogTypes.timeout]: 'Таймаут',
+};
+
+const OvertimeTypeLocalization = {
+    [OvertimeTypes.to_score_diff]: 'До разницы в N мячей',
+    [OvertimeTypes.to_score_total]: 'До N очков',
+    [OvertimeTypes.time]: 'По времени'
+};
+
+const TeamUserRoleLocalization = {
+    [TeamUserRole.moderator]: 'Модератор',
+    [TeamUserRole.member]: 'Пользователь',
+    [TeamUserRole.admin]: 'Владелец',
+};
+
+const GameBasketballPositionLocalization = {
+    [GameBasketballPosition.point_guard]: 'Разыгрывающий защитник',
+    [GameBasketballPosition.shooting_guard]: 'Атакующий защитник',
+    [GameBasketballPosition.small_forward]: 'Легкий форвард',
+    [GameBasketballPosition.power_forward]: 'Мощный форвард',
+    [GameBasketballPosition.center]: 'Центровой',
+};
+const GameBasketballPositionShortLocalization = {
+    [GameBasketballPosition.point_guard]: 'PG',
+    [GameBasketballPosition.shooting_guard]: 'SG',
+    [GameBasketballPosition.small_forward]: 'SF',
+    [GameBasketballPosition.power_forward]: 'PF',
+    [GameBasketballPosition.center]: 'C',
+};
+const WorkHandLocalization = {
+    [WorkHand.left]: 'Левая',
+    [WorkHand.right]: 'Правая'
+};
+const GameVolleyballPositionLocalization = {
+    [GameVolleyballPosition.setter]: 'Связующий',
+    [GameVolleyballPosition.libero]: 'Либеро',
+    [GameVolleyballPosition.middle_player]: 'Центральный блокирующий',
+    [GameVolleyballPosition.receiver_attacker]: 'Доигровщик',
+    [GameVolleyballPosition.dioganal]: 'Диагональный',
+};
+const GameVolleyballPositionShortLocalization = {
+    [GameVolleyballPosition.setter]: 'S',
+    [GameVolleyballPosition.libero]: 'L',
+    [GameVolleyballPosition.middle_player]: 'MP',
+    [GameVolleyballPosition.receiver_attacker]: 'RA',
+    [GameVolleyballPosition.dioganal]: 'D',
+};
+const GameVolleyballPositionShortRuLocalization = {
+    [GameVolleyballPosition.setter]: 'связ.',
+    [GameVolleyballPosition.libero]: 'либеро',
+    [GameVolleyballPosition.middle_player]: 'блок.',
+    [GameVolleyballPosition.receiver_attacker]: 'доигр.',
+    [GameVolleyballPosition.dioganal]: 'диаг.',
+};
+const VolleyballWorkHandLocalization = {
+    [VolleyballWorkHand.left]: 'Левая',
+    [VolleyballWorkHand.right]: 'Правая'
+};
+
+const VolleyballGameLogTypeLocalization = {
+    [VolleyballGameLogType.enter_game]: 'Выход на площадку',
+    [VolleyballGameLogType.exit_game]: 'Уход с площадки',
+    [VolleyballGameLogType.remove_game]: 'Удаление с площадки',
+    [VolleyballGameLogType.serve_ace]: 'Эйс',
+    [VolleyballGameLogType.serve_hit]: 'Подача',
+    [VolleyballGameLogType.serve_fault]: 'Ошибка на подаче',
+    [VolleyballGameLogType.attack_spike]: 'Результативная атака',
+    [VolleyballGameLogType.attack_shot]: 'Успешная атака',
+    [VolleyballGameLogType.attack_fault]: 'Ошибка атаки',
+    [VolleyballGameLogType.stuff_block]: 'Результативный блок',
+    [VolleyballGameLogType.block_rebound]: 'Успешный блок',
+    [VolleyballGameLogType.block_fault]: 'Ошибка на блоке',
+    [VolleyballGameLogType.excellent_receive]: 'Отличный прием',
+    [VolleyballGameLogType.receive]: 'Прием',
+    [VolleyballGameLogType.receive_fault]: 'Ошибка на приеме',
+    [VolleyballGameLogType.serve_receive]: 'Прием подачи',
+    [VolleyballGameLogType.excellent_serve_receive]: 'Отличный прием подачи',
+    [VolleyballGameLogType.serve_receive_fault]: 'Ошибка приема подачи',
+    [VolleyballGameLogType.point]: 'Очко',
+    [VolleyballGameLogType.fault]: 'Ошибка',
+    [VolleyballGameLogType.timeout]: 'Таймаут',
+};
+
+let TeamInviteExternal = class TeamInviteExternal extends BaseModel {
+    static toFront(data) { }
+    static toBack(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);
+
+let CentrifugoService = class CentrifugoService {
+    constructor(httpClient, configService) {
+        this.httpClient = httpClient;
+        this.configService = configService;
+        this.channels$ = {};
+        this.subscriptions = {};
+    }
+    listen(channel) {
+        if (channel in this.channels$) {
+            return this.channels$[channel];
+        }
+        this.channels$[channel] = new Subject();
+        const subscription = this.connect().subscribe(connected => {
+            this.subscriptions[channel] = this.addEngineSubscription(channel);
+            setTimeout(() => {
+                subscription.unsubscribe();
+            });
+        });
+        return this.channels$[channel];
+    }
+    unsubscribe(channel) {
+        if (this.subscriptions[channel]) {
+            this.subscriptions[channel].unsubscribe();
+            delete this.subscriptions[channel];
+        }
+        if (this.channels$[channel]) {
+            this.channels$[channel].complete();
+            delete this.channels$[channel];
+        }
+    }
+    connect() {
+        if (!this.initializeEngineSubject) {
+            this.initializeEngineSubject = new ReplaySubject(1);
+            this.httpClient.get('/api/v1/centrifugo/')
+                .subscribe(config => {
+                this.initializeEngine({
+                    url: this.configService.get('centrifugoUrl'),
+                    user: config.user,
+                    timestamp: config.timestamp,
+                    token: config.token,
+                    transports: ['websocket']
+                });
+                this.centrifuge.connect();
+                this.centrifuge.on('connect', () => {
+                    this.initializeEngineSubject.next(true);
+                });
+            });
+        }
+        return this.initializeEngineSubject;
+    }
+    publish(channel, message) {
+        return new Observable(observer => {
+            this.connect().subscribe(() => {
+                if (!this.subscriptions[channel]) {
+                    this.subscriptions[channel] = this.addEngineSubscription(channel);
+                }
+                this.subscriptions[channel].publish(message).then(res => {
+                    observer.next(res);
+                    observer.complete();
+                }, error => {
+                    throw error;
+                });
+            });
+        });
+    }
+    disconnect() {
+        this.centrifuge.disconnect();
+        this.initializeEngineSubject = undefined;
+        this.channels$ = {};
+        this.subscriptions = {};
+    }
+    initializeEngine(config) {
+        console.log(config);
+        this.centrifuge = new Centrifuge(config);
+    }
+    addEngineSubscription(channel) {
+        return this.centrifuge.subscribe(channel, this.resolveMessage.bind(this));
+    }
+    resolveMessage(response) {
+        const channel = response.channel;
+        if (!this.channels$[channel]) {
+            return;
+        }
+        this.channels$[channel].next(response.data);
+    }
+};
+CentrifugoService.ctorParameters = () => [
+    { type: HttpClient },
+    { type: ConfigService }
+];
+CentrifugoService.ɵprov = ɵɵdefineInjectable({ factory: function CentrifugoService_Factory() { return new CentrifugoService(ɵɵinject(HttpClient), ɵɵinject(ConfigService)); }, token: CentrifugoService, providedIn: "root" });
+CentrifugoService = __decorate([
+    Injectable({ providedIn: 'root' })
+], CentrifugoService);
+
+class StorageEngineField {
+    constructor(defaultValue, modelClass) {
+        this.modelClass = modelClass;
+        this.defaultValue = defaultValue;
+    }
+    toFront(value) {
+        if (this.modelClass) {
+            return this.modelClass.toFront(value);
+        }
+        return value;
+    }
+    toBack(value) {
+        if (this.modelClass) {
+            return this.modelClass.toBack(value);
+        }
+        return value;
+    }
+}
+class StorageEngine {
+    constructor(name, fields) {
+        this.name = name;
+        this.fields = fields;
+    }
+    addField(key, field) {
+        this.fields[key] = field;
+    }
+    save(key, value) {
+        if (!this.fields[key]) {
+            return;
+        }
+        this.setItem(`${this.name}_${key}`, this.fields[key].toBack(value));
+    }
+    get(key) {
+        if (!this.fields[key]) {
+            return;
+        }
+        let value = this.getItem(`${this.name}_${key}`);
+        if (value === null) {
+            value = this.fields[key].defaultValue;
+        }
+        if (value === null || value === undefined) {
+            return value;
+        }
+        return this.fields[key].toFront(value);
+    }
+    clear() {
+        for (const field of Object.keys(this.fields)) {
+            this.removeItem(field);
+        }
+    }
+    getItem(key) {
+        throw new Error(`Function getItem for store engine ${typeof this} not implemented`);
+    }
+    setItem(key, value) {
+        throw new Error(`Function setItem for store engine ${typeof this} not implemented`);
+    }
+    removeItem(key) {
+        throw new Error(`Function deleteItem for store engine ${typeof this} not implemented`);
+    }
+}
+
+class LocalStorageEngine extends StorageEngine {
+    setItem(key, value) {
+        localStorage.setItem(key, JSON.stringify(value));
+    }
+    getItem(key) {
+        try {
+            return JSON.parse(localStorage.getItem(key));
+        }
+        catch (e) {
+            return;
+        }
+    }
+    removeItem(key) {
+        localStorage.removeItem(key);
+    }
+}
+
+function componentDestroyed(component) {
+    if (component.constructor.__componentDestroyed$) {
+        return component.constructor.__componentDestroyed$;
+    }
+    throw new Error('Use @UntilDestroy decorator in class');
+}
+function UntilDestroy(cmpType) {
+    const def = getDef(cmpType);
+    const original = def.onDestroy;
+    cmpType.__componentDestroyed$ = new Subject();
+    def.onDestroy = function () {
+        cmpType.__componentDestroyed$.next();
+        cmpType.__componentDestroyed$.complete();
+        original.apply(this);
+    };
+}
+function getDef(type) {
+    return type.ɵcmp || type.ɵdir;
+}
+
+function getCookie(name) {
+    const value = `; ${document.cookie}`;
+    const parts = value.split(`; ${name}=`);
+    if (parts.length === 2) {
+        return parts.pop().split(';').shift();
+    }
+    return null;
+}
+
+function isTouchDevice() {
+    const prefixes = ' -webkit- -moz- -o- -ms- '.split(' ');
+    const mq = (q) => {
+        return window.matchMedia(q).matches;
+    };
+    if (('ontouchstart' in window) || window.DocumentTouch && document instanceof window.DocumentTouch) {
+        return true;
+    }
+    // include the 'heartz' as a way to have a non matching MQ to help terminate the join
+    // https://git.io/vznFH
+    const query = ['(', prefixes.join('touch-enabled),('), 'heartz', ')'].join('');
+    return mq(query);
+}
+
+function getEnumOptions(enumClass) {
+    return Object.keys(enumClass)
+        .map(v => enumClass[v])
+        .filter(v => isNaN(+v) === false)
+        .map(v => +v);
+}
+
+function handleError(error, force = false, production = true) {
+    if (!(error && (error.status === 0 || error.status === 404)) || (force && error.status !== 0)) {
+        captureException(error);
+    }
+    if (!production) {
+        console.error(error);
+    }
+}
+
+function getIconsData(folder) {
+    return [
+        { rel: 'apple-touch-icon', sizes: '180x180', href: `/assets/favicon/${folder}apple-touch-icon.png` },
+        { rel: 'icon', type: 'image/png', sizes: '32x32', href: `/assets/favicon/${folder}favicon-32x32.png` },
+        { rel: 'icon', type: 'image/png', sizes: '16x16', href: `/assets/favicon/${folder}favicon-16x16.png` },
+        { rel: 'shortcut icon', href: `/assets/favicon/${folder}favicon.ico` },
+        { rel: 'manifest', href: `/assets/favicon/${folder}site.webmanifest` },
+        { rel: 'mask-icon', href: `/assets/favicon/${folder}safari-pinned-tab.svg`, color: '#ff0000' }
+    ];
+}
+function changeFavicons(document, leagueAlias) {
+    let folder = '';
+    if (leagueAlias === 'ablmoscow') {
+        folder = 'abl/';
+    }
+    const data = getIconsData(folder);
+    for (const item of data) {
+        const link = document.createElement('link');
+        for (const key of Object.keys(item)) {
+            link.setAttribute(key, item[key]);
+        }
+        document.head.appendChild(link);
+    }
+}
+
+function markFormGroupTouched(formGroup) {
+    Object.values(formGroup.controls).forEach(control => {
+        control.markAsTouched();
+        control.markAsDirty();
+        if (control instanceof FormGroup) {
+            markFormGroupTouched(control);
+        }
+        else if (control.controls) {
+            control.controls.forEach(c => {
+                if (c instanceof FormGroup) {
+                    markFormGroupTouched(c);
+                }
+                else {
+                    c.markAsTouched();
+                    c.markAsDirty();
+                }
+            });
+        }
+    });
+}
+
+const minLengthArrayValidator = (minLength) => {
+    return (c) => {
+        return c.value.length < minLength
+            ? { minLengthArray: { valid: false } }
+            : null;
+    };
+};
+const validatePhone = (control) => {
+    if (!control.value) {
+        return null;
+    }
+    const value = `${control.value}`.replace(/\D/gi, '');
+    return value.length === 11 ? null : { invalidPhone: { valid: false } };
+};
+const validateDate = (control) => {
+    const re = /\d{2}\.\d{2}\.\d{4}/gi;
+    if (!control.value || re.test(control.value)) {
+        return null;
+    }
+    return { invalidDate: { valid: false } };
+};
+const validateEmail = (authService, selfCheck = true, ignore = []) => {
+    const subject = of(null).pipe(delay(500));
+    return (control) => {
+        if (ignore.indexOf(control.value) > -1) {
+            return of(null);
+        }
+        return subject.pipe(switchMap(() => authService.checkEmail(control.value, selfCheck).pipe(map(valid => valid ? null : { emailTaken: true }))));
+    };
+};
+const validateUrl = (control) => {
+    const re = /^(?:http(s)?:\/\/)[\w.-]+(?:\.[\w\.-]+)+[\w\-\._~:/?#[\]@!\$&'\(\)\*\+,;=.]+$/;
+    if (!control.value || re.test(control.value)) {
+        return null;
+    }
+    return { invalidUrl: true };
+};
+function fileSizeValidator(maxFileSize) {
+    return (control) => {
+        if (!control.value) {
+            return null;
+        }
+    };
+}
+
+let HttpCookieInterceptor = class HttpCookieInterceptor {
+    constructor(injector, platformId) {
+        this.injector = injector;
+        this.platformId = platformId;
+        this.isBrowser = isPlatformBrowser(this.platformId);
+    }
+    intercept(req, next) {
+        if (!this.isBrowser) {
+            return next.handle(req);
+        }
+        req = req.clone({ withCredentials: true });
+        const csrf = getCookie('csrftoken');
+        if (csrf) {
+            req = req.clone({
+                setHeaders: { 'X-CSRFToken': csrf }
+            });
+        }
+        return next.handle(req);
+    }
+};
+HttpCookieInterceptor.ctorParameters = () => [
+    { type: Injector },
+    { type: String, decorators: [{ type: Inject, args: [PLATFORM_ID,] }] }
+];
+HttpCookieInterceptor = __decorate([
+    Injectable(),
+    __param(1, Inject(PLATFORM_ID))
+], HttpCookieInterceptor);
+
+/**
+ * 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 };
+//# sourceMappingURL=mtgame-core.js.map