import { HttpClient, HttpParams } from '@angular/common/http';
import { Tournament } from '../models/tournament';
import { TournamentNews } from '../models/tournament-news';
import { Game, GameStatuses } from '../models/game';
import { GameTimelineStages } from '../models/game-timeline-stages';
import { TournamentTeam } from '../models/tournament-team';
import { TournamentStage } from '../models/tournament-stage';
import { Playoff } from '../models/playoff';
import { PaginatedResponse } from './paginated-response.interface';
import { BasketballStatistic } from '../models/basketball-statistic';
import { VolleyballStatistic } from '../models/volleyball-statistic';
import { TournamentTeamUser } from '../models/tournament-team-user';
import { TournamentStageTeam } from '../models/tournament-stage-team';
import { TournamentEvent, TournamentEventTypes } from '../models/tournament-event';
import { ConfigService } from '../services/config.service';
import { HockeyStatistic } from '../models/hockey-statistic';
import { FootballStatistic } from '../models/football-statistic';
import { LeagueUserPermissions } from '../models/league-user';
import { HandballStatistic } from '../models/handball-statistic';
import { RugbyStatistic } from '../models/rugby-statistic';
import { TournamentGroup } from '../models/tournament-group';
import { TeamAchievement } from '../models/team-achievement';
import { WaterpoloStatistic } from '../models/waterpolo-statistic';
import { TournamentRound } from '../models/tournament-round';
import { TournamentDivision } from '../models/tournament-division';
import { UserGender } from '../models/user';
import { GameUserLimitations } from '../models/game-user-limitation';
import { GameHockeyPosition } from '../models/hockey-profile';
import { GameFootballPosition } from '../models/football-profile';
import { GameHandballPosition } from '../models/handball-profile';
import { GameWaterpoloPosition } from '../models/waterpolo-profile';
import { GameBasketballPosition } from '../models/basketball-profile';
import { GameVolleyballPosition } from '../models/volleyball-profile';
import { GameRugbyPosition } from '../models/rugby-profile';
import { WrestballStatistic } from '../models/wrestball-statistic';
import { TournamentRoundTeam } from '../models/tournament-round-team';
export interface TournamentGamesFilters {
    tournamentIds?: number[];
    tournamentSeasonId?: number;
    tournamentStageId?: number;
    tournamentRoundId?: number;
    tournamentGroupId?: number;
    divisionId?: number;
    tournamentTour?: number;
    teamId?: number;
    playoffStage?: number;
    playoffRound?: number;
    playoffId?: number;
    isPlayoff?: boolean;
    status?: GameStatuses;
    statuses?: GameStatuses[];
    tournamentCourtId?: number;
    leaguePlayerId?: number;
    userId?: number;
    query?: string;
    date_from?: string;
    date_to?: string;
}
export declare type StatisticGroupByTypes = 'team' | 'user' | 'team_user' | 'tournament_team' | 'league_player' | 'tournament_team_user' | 'month' | 'win_loses';
export interface StatisticFilters {
    league_id?: number;
    tournament_id?: number;
    tournament_ids?: number[];
    tournament_season_id?: number;
    tournament_season_ids?: number[];
    tournament_team_id?: number;
    league_player_id?: number;
    tournament_team_user_id?: number;
    team_id?: number;
    team_user_id?: number;
    user_id?: number;
    tournament_stage_id?: number;
    tournament_round_id?: number;
    division_id?: number;
    tournament_group_id?: number;
    tournament_tour?: number;
    playoff_stage?: number;
    playoff_round?: number;
    playoff_id?: number;
    is_playoff?: boolean;
    date_from?: string;
    date_to?: string;
    query?: string;
    gender?: UserGender;
    basketball_position?: GameBasketballPosition;
    volleyball_position?: GameVolleyballPosition;
    hockey_position?: GameHockeyPosition;
    football_position?: GameFootballPosition;
    handball_position?: GameHandballPosition;
    waterpolo_position?: GameWaterpoloPosition;
    rugby_position?: GameRugbyPosition;
    league_player_field_value?: {
        [key: string]: string;
    };
    tournament_team_field_value?: {
        [key: string]: string;
    };
    per_game?: boolean;
    group_by: StatisticGroupByTypes;
    only_closed?: boolean;
    check_ignore_game?: boolean;
    min_games_count?: number;
    order_by?: string;
    page?: number;
    size?: number;
}
export interface StatisticLeadersFilters {
    tournament_id?: number;
    tournament_ids?: number[];
    tournament_season_id?: number;
    tournament_team_id?: number;
    team_id?: number;
    tournament_stage_id?: number;
    tournament_tour?: number;
    playoff_stage?: number;
    playoff_id?: number;
    date_from?: string;
    date_to?: string;
    per_game?: boolean;
    group_by: StatisticGroupByTypes;
    size?: number;
    fields: string[];
}
export interface TournamentEventsListFilter {
    event?: TournamentEventTypes;
    search?: string;
    tournamentTour?: number;
}
export declare class TournamentApi {
    private httpClient;
    private configService;
    constructor(httpClient: HttpClient, configService: ConfigService);
    getById(tournamentId: number): Promise<Tournament>;
    getByAlias(leagueId: number, alias: string): Promise<Tournament>;
    getSeasonTournaments(seasonTournamentId: number): Promise<Tournament[]>;
    getNews(tournamentId: number): Promise<TournamentNews[]>;
    getEvents(tournamentId: number, page: number, size: number, filters?: TournamentEventsListFilter): Promise<PaginatedResponse<TournamentEvent[]>>;
    getTournamentStages(tournamentId: number): Promise<TournamentStage[]>;
    getTournamentRounds(tournamentId: number): Promise<TournamentRound[]>;
    getTournamentDivisions(tournamentId: number): Promise<TournamentDivision[]>;
    getPlayoff(tournamentId: number): Promise<Playoff[]>;
    getPlayoffGames(playoffId: number, playoffNumber?: string): Promise<Game[]>;
    getGamesStages(tournamentId: number, roundId?: number): Promise<GameTimelineStages>;
    getGames(tournamentId: number, page: number, size: number, filters?: TournamentGamesFilters): Promise<PaginatedResponse<Game[]>>;
    getGamesDates(tournamentId: number): Promise<any>;
    getGroups(tournamentId: number): Promise<TournamentGroup[]>;
    getTeams(tournamentId: number, groupId?: number, short?: boolean, micro?: boolean): Promise<TournamentTeam[]>;
    getStageTeams(tournamentId: number): Promise<TournamentStageTeam[]>;
    getTeamsAchievements(tournamentId: number): Promise<TeamAchievement[]>;
    getTeamById(tournamentTeamId: number): Promise<TournamentTeam>;
    getTeamRoundTeams(tournamentTeamId: number): Promise<TournamentRoundTeam[]>;
    getUserById(userId: number): Promise<TournamentTeamUser>;
    getUserGames(tournamentUserId: number): Promise<Game[]>;
    downloadTable(tournamentId: number, format: 'pdf' | 'xlsx', isChess?: boolean): Promise<any>;
    getBasketballStatisticLeaders(filters: StatisticLeadersFilters): Promise<{
        [key: string]: BasketballStatistic[];
    }>;
    getVolleyballStatisticLeaders(filters: StatisticLeadersFilters): Promise<{
        [key: string]: VolleyballStatistic[];
    }>;
    getHockeyStatisticLeaders(filters: StatisticLeadersFilters): Promise<{
        [key: string]: HockeyStatistic[];
    }>;
    getFootballStatisticLeaders(filters: StatisticLeadersFilters): Promise<{
        [key: string]: FootballStatistic[];
    }>;
    getHandballStatisticLeaders(filters: StatisticLeadersFilters): Promise<{
        [key: string]: HandballStatistic[];
    }>;
    getWaterpoloStatisticLeaders(filters: StatisticLeadersFilters): Promise<{
        [key: string]: WaterpoloStatistic[];
    }>;
    getBasketballStatistic(filters?: StatisticFilters): Promise<PaginatedResponse<BasketballStatistic[]>>;
    getVolleyballStatistic(filters?: StatisticFilters): Promise<PaginatedResponse<VolleyballStatistic[]>>;
    getHockeyStatistic(filters?: StatisticFilters): Promise<PaginatedResponse<HockeyStatistic[]>>;
    getFootballStatistic(filters?: StatisticFilters): Promise<PaginatedResponse<FootballStatistic[]>>;
    getHandballStatistic(filters?: StatisticFilters): Promise<PaginatedResponse<HandballStatistic[]>>;
    getRugbyStatistic(filters?: StatisticFilters): Promise<PaginatedResponse<RugbyStatistic[]>>;
    getWaterpoloStatistic(filters?: StatisticFilters): Promise<PaginatedResponse<WaterpoloStatistic[]>>;
    getWrestballStatistic(filters?: StatisticFilters): Promise<PaginatedResponse<WrestballStatistic[]>>;
    getTournamentTeamUsers(tournamentTeamId: number, includes?: string[]): Promise<TournamentTeamUser[]>;
    myPermission(tournamentId: number): Promise<LeagueUserPermissions[]>;
    getTournamentTeamTournaments(tournamentTeamId: number): Promise<Tournament[]>;
    getTournamentUserTournaments(tournamentTeamUserId: number): Promise<Tournament[]>;
    getTournamentTeamUsersLimitation(tournamentTeamId: number): Promise<GameUserLimitations[]>;
    downloadTeamSanctionList(tournamentTeamId: number, fileType: 'pdf' | 'xlsx' | 'html'): Promise<any>;
}
export declare function applyGamesFilters(filters: TournamentGamesFilters, params: HttpParams): HttpParams;
export declare function applyStatisticFilters(filters: StatisticFilters): object;
export declare function applyStatisticLeadersFilters(filters: StatisticLeadersFilters, params: HttpParams): HttpParams;