@mtgame/core 0.0.37 → 0.0.39

package/api/basketball-game-api.d.ts

@@ -15,4 +15,5 @@ export declare class BasketballGameApi {
     getUserStatistic(gameId: number): Promise<BasketballGameStatistic[]>;
     getLogs(gameId: number): Promise<BasketballGameLog[]>;
     downloadProtocol(gameId: number, fileType: 'xlsx' | 'pdf'): Promise<any>;
+    downloadFibaProtocol(gameId: number, fileType: 'xlsx' | 'pdf'): Promise<any>;
 }

package/api/league-api.d.ts

@@ -2,9 +2,11 @@ import { HttpClient } from '@angular/common/http';
 import { League } from '../models/league';
 import { Tournament } from '../models/tournament';
 import { ConfigService } from '../services/config.service';
-import { TournamentEventsListFilter } from './tournament-api';
+import { TournamentEventsListFilter, TournamentGamesFilters } from './tournament-api';
 import { PaginatedResponse } from './paginated-response.interface';
 import { TournamentEvent } from '../models/tournament-event';
+import { TournamentSeason } from '../models/tournament-season';
+import { Game } from '../models/game';
 export declare class LeagueApi {
     private httpClient;
     private configService;
@@ -13,4 +15,7 @@ export declare class LeagueApi {
     getByDomain(domain: string): Promise<League>;
     getTournaments(leagueId: number): Promise<Tournament[]>;
     getEvents(leagueId: number, page: number, size: number, filters?: TournamentEventsListFilter): Promise<PaginatedResponse<TournamentEvent[]>>;
+    getTournamentSeasons(leagueId: number): Promise<TournamentSeason[]>;
+    getGames(leagueId: number, page: number, size: number, filters: TournamentGamesFilters): Promise<PaginatedResponse<Game[]>>;
+    getSeasons(leagueId: number, notClosed?: boolean): Promise<TournamentSeason[]>;
 }

package/api/league-news-api.d.ts

@@ -6,8 +6,9 @@ export declare class LeagueNewsApi {
     private httpClient;
     private configService;
     constructor(httpClient: HttpClient, configService: ConfigService);
-    getLeagueNewsList(leagueId: number): Promise<PaginatedResponse<LeagueNews[]>>;
+    getLeagueNewsList(leagueId: number, page: number, size: number): Promise<PaginatedResponse<LeagueNews[]>>;
     getMainLeagueNews(leagueId: number): Promise<LeagueNews>;
+    getMainLeagueNewsList(leagueId: number): Promise<LeagueNews[]>;
     getNewsById(newsId: number): Promise<LeagueNews>;
     getTournamentNewsList(tournamentId: number): Promise<PaginatedResponse<LeagueNews[]>>;
 }

package/api/media-api.d.ts

@@ -11,6 +11,10 @@ export interface GameMediaFilters {
     playoffId?: number;
     status?: GameStatuses;
 }
+export interface MediaFilters {
+    mediaType?: 'photo' | 'video' | 'live_video';
+    sort?: string;
+}
 export declare class MediaApi {
     private httpClient;
     private configService;
@@ -18,6 +22,7 @@ export declare class MediaApi {
     getMedia(mediaId: number): Promise<MediaItem>;
     getTournamentGameMedia(tournamentId: number, page: number, size: number, filters?: GameMediaFilters): Promise<PaginatedResponse<Game[]>>;
     getLeagueGameMedia(leagueId: number, page: number, size: number, filters?: GameMediaFilters): Promise<PaginatedResponse<Game[]>>;
+    getLeagueMedia(leagueId: number, page: number, size: number, filters?: MediaFilters): Promise<PaginatedResponse<MediaItem[]>>;
     getGameMediaById(gameId: number): Promise<Game>;
     getGameMedia(gameId: number): Promise<MediaItem[]>;
     createZip(mediaIds: number[]): Promise<any>;

package/api/public-api.d.ts

@@ -14,6 +14,7 @@ export * from './team-api';
 export * from './team-event-api';
 export { TournamentApi, TournamentGamesFilters, TournamentEventsListFilter, StatisticGroupByTypes, StatisticFilters } from './tournament-api';
 export { TournamentJoinApi } from './tournament-join-api';
+export * from './tournament-season-api';
 export { TournamentStageApi } from './tournament-stage-api';
 export * from './user-api';
 export { VolleyballGameApi } from './volleyball-game-api';

package/api/tournament-api.d.ts

@@ -22,10 +22,12 @@ export interface TournamentGamesFilters {
     playoffStage?: number;
     playoffId?: number;
     status?: GameStatuses;
+    statuses?: GameStatuses[];
 }
 export declare type StatisticGroupByTypes = 'team' | 'user' | 'team_user' | 'tournament_team' | 'tournament_team_user' | 'month' | 'win_loses';
 export interface StatisticFilters {
     tournament_id?: number;
+    tournament_season_id?: number;
     tournament_team_id?: number;
     tournament_team_user_id?: number;
     team_id?: number;
@@ -43,12 +45,13 @@ export interface StatisticFilters {
 export interface TournamentEventsListFilter {
     event?: TournamentEventTypes;
     search?: string;
+    tournamentTour?: number;
 }
 export declare class TournamentApi {
     private httpClient;
     private configService;
     constructor(httpClient: HttpClient, configService: ConfigService);
-    getByAlias(alias: string): Promise<Tournament>;
+    getByAlias(leagueId: number, alias: string): Promise<Tournament>;
     getNews(tournamentId: number): Promise<TournamentNews[]>;
     getEvents(tournamentId: number, page: number, size: number, filters?: TournamentEventsListFilter): Promise<PaginatedResponse<TournamentEvent[]>>;
     getTournamentStages(tournamentId: number): Promise<TournamentStage[]>;

package/api/tournament-season-api.d.ts

@@ -0,0 +1,23 @@
+import { HttpClient } from '@angular/common/http';
+import { TournamentSeason } from '../models/tournament-season';
+import { ConfigService } from '../services/config.service';
+import { Game } from '../models/game';
+import { Tournament } from '../models/tournament';
+import { TournamentEventsListFilter, TournamentGamesFilters } from './tournament-api';
+import { PaginatedResponse } from './paginated-response.interface';
+import { TournamentEvent } from '../models/tournament-event';
+import { GameMediaFilters } from './media-api';
+import { TournamentTeam } from '../models/tournament-team';
+import { GameTimelineStages } from '../models/game-timeline-stages';
+export declare class TournamentSeasonApi {
+    private httpClient;
+    private configService;
+    constructor(httpClient: HttpClient, configService: ConfigService);
+    getByAlias(leagueId: number, alias: string): Promise<TournamentSeason>;
+    getTournaments(seasonId: number): Promise<Tournament[]>;
+    getGames(seasonId: number, page: number, size: number, filters: TournamentGamesFilters): Promise<PaginatedResponse<Game[]>>;
+    getEvents(seasonId: number, page: number, size: number, filters?: TournamentEventsListFilter): Promise<PaginatedResponse<TournamentEvent[]>>;
+    getGameMedia(seasonId: number, page: number, size: number, filters: GameMediaFilters): Promise<PaginatedResponse<Game[]>>;
+    getTeams(seasonId: number): Promise<TournamentTeam[]>;
+    getGamesStages(seasonId: number): Promise<GameTimelineStages>;
+}

package/bundles/mtgame-core.umd.js

@@ -1093,6 +1093,47 @@
     }(BaseModel));
 
 
+    (function (TournamentSeasonStatuses) {
+        TournamentSeasonStatuses[TournamentSeasonStatuses["open"] = 0] = "open";
+        TournamentSeasonStatuses[TournamentSeasonStatuses["in_progress"] = 1] = "in_progress";
+        TournamentSeasonStatuses[TournamentSeasonStatuses["closed"] = 2] = "closed";
+    })(exports.TournamentSeasonStatuses || (exports.TournamentSeasonStatuses = {}));
+    var TournamentSeason = /** @class */ (function (_super) {
+        __extends(TournamentSeason, _super);
+        function TournamentSeason() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        TournamentSeason.toFront = function (data) { };
+        TournamentSeason.toBack = function (data) { };
+        __decorate([
+            ToFrontHook
+        ], TournamentSeason, "toFront", null);
+        __decorate([
+            ToBackHook
+        ], TournamentSeason, "toBack", null);
+        TournamentSeason = __decorate([
+            ModelInstance({
+                mappingFields: {
+                    id: 'id',
+                    name: 'name',
+                    alias: 'alias',
+                    logo: 'logo',
+                    cover: 'cover',
+                    preview_image: 'previewImage',
+                    status: 'status',
+                },
+                relation: {
+                    logo: File,
+                    cover: File,
+                    previewImage: File,
+                    status: enumField(exports.TournamentSeasonStatuses),
+                }
+            })
+        ], TournamentSeason);
+        return TournamentSeason;
+    }(BaseModel));
+
+
     (function (TournamentTypes) {
         TournamentTypes["group"] = "group";
         TournamentTypes["elimination"] = "elimination";
@@ -1269,7 +1310,10 @@
                     teams_count: 'teamsCount',
                     closest_game_datetime: 'closestGameDatetime',
                     status: 'status',
-                    team_winner: 'teamWinner'
+                    team_winner: 'teamWinner',
+                    team_second: 'teamSecond',
+                    team_third: 'teamThird',
+                    season: 'season',
                 },
                 relation: {
                     logo: File,
@@ -1282,7 +1326,10 @@
                     date: DateTimeField,
                     league: League,
                     status: enumField(exports.TournamentStatuses),
-                    teamWinner: TournamentTeamWinner
+                    teamWinner: TournamentTeamWinner,
+                    teamSecond: TournamentTeamWinner,
+                    teamThird: TournamentTeamWinner,
+                    season: TournamentSeason,
                 }
             })
         ], Tournament);
@@ -1595,6 +1642,7 @@
                     tournament_court: 'tournamentCourt',
                     media_count: 'mediaCount',
                     media: 'media',
+                    tournament: 'tournament',
                 },
                 relation: {
                     status: enumField(exports.GameStatuses),
@@ -1607,6 +1655,7 @@
                     hockeyGameConfig: HockeyGameConfig,
                     tournamentCourt: LeagueCourt,
                     media: listField(MediaItem),
+                    tournament: Tournament,
                 }
             })
         ], Game);
@@ -1709,6 +1758,7 @@
                     tournament: 'tournament',
                     team: 'team',
                     group: 'group',
+                    final_standing: 'finalStanding',
                     games_count: 'gamesCount',
                     won_games_count: 'wonGamesCount',
                     draw_games_count: 'drawGamesCount',
@@ -2397,6 +2447,14 @@
                 });
             });
         };
+        BasketballGameApi.prototype.downloadFibaProtocol = function (gameId, fileType) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament_basketball_game/" + gameId + "/game_protocol_fiba/?file_type=" + fileType, { responseType: 'blob' })
+                            .toPromise()];
+                });
+            });
+        };
         BasketballGameApi.ctorParameters = function () { return [
             { type: http.HttpClient },
             { type: ConfigService }
@@ -3120,6 +3178,9 @@
                         if (filters.search) {
                             params = params.set('search', filters.search);
                         }
+                        if (filters.tournamentTour) {
+                            params = params.set('tournament_tour', filters.tournamentTour.toString());
+                        }
                     }
                     return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/league/" + leagueId + "/events/", { params: params, observe: 'response' }).pipe(operators.map(function (result) { return ({
                             total: +result.headers.get('X-Page-Count'),
@@ -3128,6 +3189,58 @@
                 });
             });
         };
+        LeagueApi.prototype.getTournamentSeasons = function (leagueId) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/league/" + leagueId + "/tournament_seasons/").pipe(operators.map(function (result) { return TournamentSeason.toFront(result); })).toPromise()];
+                });
+            });
+        };
+        LeagueApi.prototype.getGames = function (leagueId, page, size, filters) {
+            return __awaiter(this, void 0, void 0, function () {
+                var params, statuses;
+                return __generator(this, function (_a) {
+                    params = new http.HttpParams().set('page', page.toString());
+                    if (size) {
+                        params = params.set('size', size.toString());
+                    }
+                    if (filters.tournamentStageId) {
+                        params = params.set('tournament_stage_id', filters.tournamentStageId.toString());
+                    }
+                    if (filters.tournamentTour) {
+                        params = params.set('tournament_tour', filters.tournamentTour.toString());
+                    }
+                    if (filters.playoffStage) {
+                        params = params.set('playoff_stage', filters.playoffStage.toString());
+                    }
+                    if (filters.teamId) {
+                        params = params.set('team_id', filters.teamId.toString());
+                    }
+                    if (filters.status) {
+                        params = params.set('status', exports.GameStatuses[filters.status]);
+                    }
+                    if (filters.statuses) {
+                        statuses = filters.statuses.map(function (i) { return exports.GameStatuses[i]; });
+                        params = params.set('statuses', statuses.join(','));
+                    }
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/league/" + leagueId + "/games/", { params: params, observe: 'response' }).pipe(operators.map(function (result) { return ({
+                            total: +result.headers.get('X-Page-Count'),
+                            data: Game.toFront(result.body)
+                        }); })).toPromise()];
+                });
+            });
+        };
+        LeagueApi.prototype.getSeasons = function (leagueId, notClosed) {
+            return __awaiter(this, void 0, void 0, function () {
+                var params;
+                return __generator(this, function (_a) {
+                    params = new http.HttpParams().set('not_closed', notClosed ? '1' : '');
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/league/" + leagueId + "/tournament_seasons/", { params: params })
+                            .pipe(operators.map(function (result) { return TournamentSeason.toFront(result); }))
+                            .toPromise()];
+                });
+            });
+        };
         LeagueApi.ctorParameters = function () { return [
             { type: http.HttpClient },
             { type: ConfigService }
@@ -3144,10 +3257,13 @@
             this.httpClient = httpClient;
             this.configService = configService;
         }
-        LeagueNewsApi.prototype.getLeagueNewsList = function (leagueId) {
+        LeagueNewsApi.prototype.getLeagueNewsList = function (leagueId, page, size) {
             return __awaiter(this, void 0, void 0, function () {
+                var params;
                 return __generator(this, function (_a) {
-                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/league/" + leagueId + "/news/", { observe: 'response' })
+                    params = new http.HttpParams().set('page', page.toString())
+                        .set('size', size.toString());
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/league/" + leagueId + "/news/", { params: params, observe: 'response' })
                             .pipe(operators.map(function (response) { return ({
                             total: +response.headers.get('X-Page-Count'),
                             data: LeagueNews.toFront(response.body)
@@ -3165,6 +3281,15 @@
                 });
             });
         };
+        LeagueNewsApi.prototype.getMainLeagueNewsList = function (leagueId) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/league/" + leagueId + "/news/?is_main=true")
+                            .pipe(operators.map(function (response) { return LeagueNews.toFront(response); }))
+                            .toPromise()];
+                });
+            });
+        };
         LeagueNewsApi.prototype.getNewsById = function (newsId) {
             return __awaiter(this, void 0, void 0, function () {
                 return __generator(this, function (_a) {
@@ -3277,6 +3402,26 @@
                 });
             });
         };
+        MediaApi.prototype.getLeagueMedia = function (leagueId, page, size, filters) {
+            if (filters === void 0) { filters = {}; }
+            return __awaiter(this, void 0, void 0, function () {
+                var params;
+                return __generator(this, function (_a) {
+                    params = new http.HttpParams().set('page', page.toString()).set('size', size.toString());
+                    if (filters.mediaType) {
+                        params = params.set('media_type', filters.mediaType);
+                    }
+                    if (filters.sort) {
+                        params = params.set('sort', filters.sort);
+                    }
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/league/" + leagueId + "/media/", { params: params, observe: 'response' })
+                            .pipe(operators.map(function (response) { return ({
+                            total: +response.headers.get('X-Page-Count'),
+                            data: MediaItem.toFront(response.body)
+                        }); })).toPromise()];
+                });
+            });
+        };
         MediaApi.prototype.getGameMediaById = function (gameId) {
             return __awaiter(this, void 0, void 0, function () {
                 return __generator(this, function (_a) {
@@ -5108,10 +5253,10 @@
             this.httpClient = httpClient;
             this.configService = configService;
         }
-        TournamentApi.prototype.getByAlias = function (alias) {
+        TournamentApi.prototype.getByAlias = function (leagueId, alias) {
             return __awaiter(this, void 0, void 0, function () {
                 return __generator(this, function (_a) {
-                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament/" + alias + "/")
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/league/" + leagueId + "/tournaments/" + alias + "/")
                             .pipe(operators.map(function (result) { return Tournament.toFront(result); }))
                             .toPromise()];
                 });
@@ -5139,6 +5284,9 @@
                         if (filters.search) {
                             params = params.set('search', filters.search);
                         }
+                        if (filters.tournamentTour) {
+                            params = params.set('tournament_tour', filters.tournamentTour.toString());
+                        }
                     }
                     return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament/" + tournamentId + "/events/", { params: params, observe: 'response' })
                             .pipe(operators.map(function (result) { return ({
@@ -5182,7 +5330,7 @@
         TournamentApi.prototype.getGames = function (tournamentId, page, size, filters) {
             if (filters === void 0) { filters = {}; }
             return __awaiter(this, void 0, void 0, function () {
-                var params;
+                var params, statuses;
                 return __generator(this, function (_a) {
                     params = new http.HttpParams().set('page', page.toString());
                     if (size) {
@@ -5203,6 +5351,10 @@
                     if (filters.status) {
                         params = params.set('status', exports.GameStatuses[filters.status]);
                     }
+                    if (filters.statuses) {
+                        statuses = filters.statuses.map(function (i) { return exports.GameStatuses[i]; });
+                        params = params.set('statuses', statuses.join(','));
+                    }
                     return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament/" + tournamentId + "/games/", { params: params, observe: 'response' })
                             .pipe(operators.map(function (result) { return ({
                             total: +result.headers.get('X-Page-Count'),
@@ -5485,6 +5637,147 @@
         return TournamentJoinApi;
     }());
 
+    var TournamentSeasonApi = /** @class */ (function () {
+        function TournamentSeasonApi(httpClient, configService) {
+            this.httpClient = httpClient;
+            this.configService = configService;
+        }
+        TournamentSeasonApi.prototype.getByAlias = function (leagueId, alias) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/league/" + leagueId + "/tournament_seasons/" + alias + "/").pipe(operators.map(function (result) { return TournamentSeason.toFront(result); })).toPromise()];
+                });
+            });
+        };
+        TournamentSeasonApi.prototype.getTournaments = function (seasonId) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament_season/" + seasonId + "/tournaments/").pipe(operators.map(function (result) { return Tournament.toFront(result); })).toPromise()];
+                });
+            });
+        };
+        TournamentSeasonApi.prototype.getGames = function (seasonId, page, size, filters) {
+            return __awaiter(this, void 0, void 0, function () {
+                var params, statuses;
+                return __generator(this, function (_a) {
+                    params = new http.HttpParams().set('page', page.toString());
+                    if (size) {
+                        params = params.set('size', size.toString());
+                    }
+                    if (filters.tournamentStageId) {
+                        params = params.set('tournament_stage_id', filters.tournamentStageId.toString());
+                    }
+                    if (filters.tournamentTour) {
+                        params = params.set('tournament_tour', filters.tournamentTour.toString());
+                    }
+                    if (filters.playoffStage) {
+                        params = params.set('playoff_stage', filters.playoffStage.toString());
+                    }
+                    if (filters.teamId) {
+                        params = params.set('team_id', filters.teamId.toString());
+                    }
+                    if (filters.status) {
+                        params = params.set('status', exports.GameStatuses[filters.status]);
+                    }
+                    if (filters.statuses) {
+                        statuses = filters.statuses.map(function (i) { return exports.GameStatuses[i]; });
+                        params = params.set('statuses', statuses.join(','));
+                    }
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament_season/" + seasonId + "/games/", { params: params, observe: 'response' }).pipe(operators.map(function (result) { return ({
+                            total: +result.headers.get('X-Page-Count'),
+                            data: Game.toFront(result.body)
+                        }); })).toPromise()];
+                });
+            });
+        };
+        TournamentSeasonApi.prototype.getEvents = function (seasonId, page, size, filters) {
+            return __awaiter(this, void 0, void 0, function () {
+                var params;
+                return __generator(this, function (_a) {
+                    params = new http.HttpParams().set('page', page.toString())
+                        .set('size', size.toString());
+                    if (filters) {
+                        if (filters.event) {
+                            params = params.set('event', exports.TournamentEventTypes[filters.event]);
+                        }
+                        if (filters.search) {
+                            params = params.set('search', filters.search);
+                        }
+                        if (filters.tournamentTour) {
+                            params = params.set('tournament_tour', filters.tournamentTour.toString());
+                        }
+                    }
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament_season/" + seasonId + "/events/", { params: params, observe: 'response' })
+                            .pipe(operators.map(function (result) { return ({
+                            total: +result.headers.get('X-Page-Count'),
+                            data: TournamentEvent.toFront(result.body)
+                        }); }))
+                            .toPromise()];
+                });
+            });
+        };
+        TournamentSeasonApi.prototype.getGameMedia = function (seasonId, page, size, filters) {
+            return __awaiter(this, void 0, void 0, function () {
+                var params;
+                return __generator(this, function (_a) {
+                    params = new http.HttpParams().set('page', page.toString()).set('size', size.toString());
+                    if (filters) {
+                        if (filters.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', exports.GameStatuses[filters.status]);
+                        }
+                    }
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament_season/" + seasonId + "/game_media/", { observe: 'response', params: params })
+                            .pipe(operators.map(function (response) {
+                            return {
+                                total: +response.headers.get('X-Page-Count'),
+                                data: Game.toFront(response.body)
+                            };
+                        })).toPromise()];
+                });
+            });
+        };
+        TournamentSeasonApi.prototype.getTeams = function (seasonId) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament_season/" + seasonId + "/teams/").pipe(operators.map(function (result) { return TournamentTeam.toFront(result); })).toPromise()];
+                });
+            });
+        };
+        TournamentSeasonApi.prototype.getGamesStages = function (seasonId) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament_season/" + seasonId + "/games_stages/")
+                            .pipe(operators.map(function (data) { return GameTimelineStages.toFront(data); }))
+                            .toPromise()];
+                });
+            });
+        };
+        TournamentSeasonApi.ctorParameters = function () { return [
+            { type: http.HttpClient },
+            { type: ConfigService }
+        ]; };
+        TournamentSeasonApi.ɵprov = core.ɵɵdefineInjectable({ factory: function TournamentSeasonApi_Factory() { return new TournamentSeasonApi(core.ɵɵinject(http.HttpClient), core.ɵɵinject(ConfigService)); }, token: TournamentSeasonApi, providedIn: "root" });
+        TournamentSeasonApi = __decorate([
+            core.Injectable({ providedIn: 'root' })
+        ], TournamentSeasonApi);
+        return TournamentSeasonApi;
+    }());
+
     var TournamentStageApi = /** @class */ (function () {
         function TournamentStageApi(httpClient, configService) {
             this.httpClient = httpClient;
@@ -6858,6 +7151,8 @@
     exports.TournamentJoinData = TournamentJoinData;
     exports.TournamentJoinTeam = TournamentJoinTeam;
     exports.TournamentNews = TournamentNews;
+    exports.TournamentSeason = TournamentSeason;
+    exports.TournamentSeasonApi = TournamentSeasonApi;
     exports.TournamentSettings = TournamentSettings;
     exports.TournamentStage = TournamentStage;
     exports.TournamentStageApi = TournamentStageApi;