import OddsModel from '@mediaplatform/sportal365-odds-utils/types/models/odds.model';
import { CSS } from '@stitches/react/types/css-util';
import { BasketballSDKOptions, BasketballWidgetType } from './basketball/basketball';
import { FootballOddMarketValueTypes } from './football';
import { TennisSDKOptions, TennisWidgetType } from './tennis/tennis';
export declare const AllEvents: {
    readonly team: "team";
    readonly event: "event";
    readonly bettingLogo: "bettingLogo";
    readonly bettingMarketValue: "bettingMarketValue";
    readonly matchScore: "matchScore";
    readonly onPredictionSuccess: "onPredictionSuccess";
    readonly onPredictionError: "onPredictionError";
    readonly onUserInteraction: "onUserInteraction";
};
export type GlobalRootType<T> = {
    id?: string;
    widgetId?: string;
    root: T;
};
export type EntityTypes = 'competition' | 'betting_m_value' | 'betting_logo' | 'team' | 'player' | 'event' | 'dropdownSelection' | 'tabSelection' | 'showMore' | 'coach' | 'user_interaction' | 'showPrevious';
export type WinnerTeam = 'YES' | 'NO' | 'NOT_AVAILABLE';
export type AgeRestrictionDisplay = 'none' | 'visible' | 'visible-icon' | 'visible-label';
export interface IProviderLink {
    applicationId: string;
    betslipLink: string;
    fallbackLink: string;
}
export interface IOdds {
    eventId?: string;
    odds?: IOdd[];
}
export interface IOdd {
    eventId?: string;
    oddProvider?: IOddProvider;
    '1x2'?: IOneXTwo;
    bothScore?: IBothScore;
    doubleChance?: IDoubleChance;
    over?: unknown;
    under?: unknown;
}
export interface IOneXTwo {
    '1': IMarket;
    '2': IMarket;
    x?: IMarket;
}
export interface IBothScore {
    no: IMarket;
    yes: IMarket;
}
export interface IDoubleChance {
    '12': IMarket;
    '1x': IMarket;
    x2: IMarket;
}
export interface IMarket {
    odds: string;
    coupon?: string;
    url: string;
    links?: IMarketLink[];
    provider_info?: IProviderInfo;
}
export interface IOddProvider {
    id?: string | number;
    name?: string;
    assets?: IAssets;
    url?: string;
    logo?: string;
    links?: IProviderLink[];
}
export interface IMarketLink {
    application: string;
    link: string;
}
export interface IProviderInfo {
    event_id: string;
    market_id: string;
    selection_id: string;
}
interface ISubscriberOddCoefficientInfo {
    name?: string;
    market?: string;
    link?: IMarket['url'];
    entity_type: EntityTypes;
}
interface ISubscriberOddProviderInfo {
    id: IOddProvider['id'];
    name: IOddProvider['name'];
    link: IOddProvider['url'];
    entity_type: EntityTypes;
}
interface ISubscriberTeamInfo {
    id: ITeam['id'];
    name: ITeam['name'];
    entity_type: EntityTypes;
}
interface ISubscriberCompetitionInfo {
    id: ITournament['id'];
    name: ITournament['name'];
    entity_type: EntityTypes;
}
export type ISubscriberInfo = ISubscriberCompetitionInfo | ISubscriberOddCoefficientInfo | ISubscriberOddProviderInfo | ISubscriberTeamInfo;
export declare enum WidgetTypes {
    TOURNAMENT = "tournament",
    TEAM = "team",
    PLAYER = "player",
    EVENT = "event",
    H2H = "h2h",
    MULTISPORT = "multisport"
}
export type WidgetType = 'tournament' | 'team' | 'player' | 'event' | 'h2h' | 'multisport';
export type Attributes = {
    onLoaded?: (data: unknown) => void;
};
export type Languages = 'en' | 'bg' | 'el' | 'ro' | 'tr' | 'de' | 'pt' | 'it' | 'sr' | 'hu';
export type Themes = 'light' | 'dark' | 'client';
export declare enum THEME_VARIANTS {
    LIGHT = "light",
    DARK = "dark",
    CLIENT = "client"
}
export declare enum NavButtonVariant {
    DEFAULT = "default",
    COMPACT = "compact"
}
export type WinnerReason = 'agg' | 'pen';
export type Theme = {
    colors?: object;
    fonts?: object;
    space?: object;
    sizes?: object;
    fontSizes?: object;
    radii?: object;
    zIndices?: object;
};
export type Markets = OddsMarketTypes | '12' | '1x2' | 'bothScore' | 'doubleChance' | 'overUnder' | 'over' | 'under';
export type OddMarketValueTypes = OddFormat | FootballOddMarketValueTypes;
export type BaseEvent = {
    id?: string;
    name?: string;
    entity_type: string;
};
export type TeamEvent = BaseEvent;
export type CompetitionEvent = BaseEvent;
export type BettingMarketEvent = BaseEvent & {
    market?: string;
    link?: string;
};
export type BettingProviderEvent = BaseEvent & {
    link?: string;
};
export type EventTypes = 'loaded' | 'event' | 'competition' | 'team' | 'bettingLogo' | 'bettingMarketValue' | 'matchScore' | 'onPredictionSuccess' | 'onPredictionError' | 'player' | 'coach' | 'onUserInteraction';
export type EventData = TeamEvent | CompetitionEvent | BettingMarketEvent | BettingProviderEvent;
export interface SDKDateOptions {
    dataConfigLang: Languages;
    dataConfigTimezone: string;
}
export interface FootballSDKOptions extends SDKDateOptions {
    dataConfigApiUrl: string;
    dataConfigMultisportApiUrl: string;
    dataConfigApiKey: string;
    dataConfigStandingsApiUrl: string;
    dataConfigProject: string;
    dataConfigCompetitionList: string;
    dataConfigOddClient: string;
}
export interface IceHockeySDKOptions extends SDKDateOptions {
    dataConfigApiUrl: string;
    dataConfigMultisportApiUrl: string;
    dataConfigStandingsApiUrl: string;
    dataConfigPlayoffApiUrl: string;
    dataConfigApiKey: string;
    dataConfigProject: string;
    dataConfigCompetitionList: string;
    dataConfigOddClient: string;
}
export type SDKOptions = FootballSDKOptions & BasketballSDKOptions & TennisSDKOptions & IceHockeySDKOptions;
export interface LoadSmpData {
    sdkOptions: SDKOptions;
    themes?: {
        [key in Themes]?: unknown;
    };
    widgetAttributes?: IDictionary<string>;
    onLoaded?: (data: unknown) => void;
    getAuthToken: () => string;
    signOut: () => void;
    fansUnitedSdk?: IFansUnitedSDK;
}
export interface IDictionary<TValue> {
    [id: string]: TValue;
}
export type ShortNameType = 'three_letter_code' | 'short_name';
export type ShortStatusType = 'full_name' | 'short_name' | 'shortName';
export type ParseWidgetsDataReturn<T> = {
    shadow?: ShadowRoot | null;
    element?: HTMLElement;
    config?: T;
};
export interface ISubscriberInfoFn {
    (value: ISubscriberInfo, clickType: EventTypes): void;
}
export type BaseWidgetProps<T> = ParseWidgetsDataReturn<T> & LoadSmpData & {
    id?: string;
    subscribers: {
        [key: string]: ISubscriberFn[];
    };
    handleClick?: ISubscriberInfoFn;
    cuid?: string;
};
export type RefreshTimes = 'super_fast' | 'fast' | 'medium' | 'slow' | 'super_slow' | 'never';
export interface ISubscriberFn {
    (data: unknown): void;
}
export interface IConfigDate {
    date: string;
    dateFormat: string;
    dateRange?: number;
}
export interface IConfigOdds {
    bettingId: string | null;
    display: boolean;
    preEventOnly?: boolean;
    market?: Markets;
    marketValueType?: OddMarketValueTypes;
}
export interface IConfigEntityLinks {
    player?: IEntityLink;
    team?: IEntityLink;
    competition?: IEntityLink;
    standings?: IEntityLink;
    match?: IEntityLinksMatch;
    configuration?: IEntityLinksConfiguration;
    standings_tournament?: IEntityLink;
    game?: IEntityLinksMatch;
    slug?: {
        team: string;
        competition: string;
        match: string;
    };
}
export type IConfigEntityLinksOptional = IConfigEntityLinks | undefined | null;
export interface IMultisportConfigEntityLinks {
    football: IConfigEntityLinks;
    basketball: IConfigEntityLinks;
    tennis: IConfigEntityLinks;
    handball: IConfigEntityLinks;
    iceHockey: IConfigEntityLinks;
    rollerHockey: IConfigEntityLinks;
    rugby: IConfigEntityLinks;
    cricket: IConfigEntityLinks;
    cycling: IConfigEntityLinks;
    motorsports: IConfigEntityLinks;
}
export interface IEntityLink {
    url: string;
}
export interface IEntityLinksMatch extends IEntityLink {
    sort: IEntityLinksMatchSort;
}
export interface IEntityLinksMatchSort {
    criteria: string;
    direction: string;
}
export interface IEntityLinksConfiguration {
    newWindow: boolean;
}
export interface IAssetsEntity {
    url: string | null;
}
export interface IAssets {
    flag?: IAssetsEntity;
    logo?: IAssetsEntity;
    thumb?: IAssetsEntity;
    image?: IAssetsEntity;
    homeKit?: IAssetsEntity;
    awayKit?: IAssetsEntity;
    squadImage?: IAssetsEntity;
    headshot?: IAssetsEntity | string;
}
export interface ICountry {
    id: string;
    name: string;
    assets?: IAssets;
    logo?: string;
    url_flag?: string;
    entityType?: string;
}
export interface IStage {
    id: string;
    name: string;
    type: string;
    startDate: string;
    endDate: string;
    orderInSeason?: number;
    coverage?: string;
    status?: string;
    slug: string;
}
export interface ITournament {
    id: string;
    legacy_id?: string;
    name: string;
    slug: string | null;
    country: ICountry;
    gender?: string;
    type: string;
    region: string;
    assets: IAssets | null;
    stage?: IStage;
    round?: IRound;
    seasons?: ISeason[];
    regionalLeague?: boolean;
    logo?: string;
    hasMultipleStages?: boolean;
    seasonYear?: string;
    competition?: ICompetition;
    entityType?: string;
}
export interface ICompetition {
    id: string;
    name: string;
    slug: string;
    country: ICountry;
    entityType: string;
    assets: IAssets;
}
export interface ITeamStage {
    statistics: IStatistic;
    stage?: IStage;
}
export interface ITournamentSeason {
    id?: number;
    name?: string;
    active?: boolean;
}
export interface IBaseTeam {
    id: number | string;
    name: string;
    slug?: string;
    type?: string;
    logo?: string;
    threeLetterCode?: string;
    shortName?: string;
    urlTarget?: string;
}
export interface ITeam extends IBaseTeam {
    gender?: string;
    national?: boolean;
    assets?: IAssets;
    shirtColor?: string;
    url?: string;
    country?: ICountry;
    founded?: number;
    venue?: {
        name: string;
    };
    social?: Record<string, string>;
    winner?: {
        reason: {
            name: string | null;
        };
        value: WinnerTeam;
    };
}
export interface IMatchH2HTeam extends IBaseTeam {
    assets?: IAssets | null;
}
export interface ISeason {
    id: string;
    name: string;
    status: string;
    tournament?: ITournament;
    entityType?: string;
    competition?: ITournament;
    assets?: IAssets;
    active?: boolean;
    slug?: string;
}
export interface ITeamSeason {
    id: string;
    active: boolean;
    name: string;
    tournament?: ITournament;
}
export interface IPlayer {
    id: string;
    name: string;
    slug: string;
    position: string;
    country: ICountry;
    birthdate: string;
    profile: {
        height: string;
        weight: string;
    };
    assets: {
        image: {
            url: string;
        };
        thumb: {
            url: string;
        };
        thumb_transparent_background: {
            url: string;
        };
    };
    social: {
        twitter_id: string;
        facebook_id: string;
        instagram_id: string;
        web: string;
        youtube_channel_id: string;
    };
}
export interface IStatistic {
    name?: string;
    value: string;
    key?: string;
}
export interface IRound {
    key: string;
    name: string;
    type: string;
}
export interface IVenue {
    id: number;
    name: string;
    assets?: IAssets;
}
export interface IStatus {
    id: string;
    name: string;
    type: string;
    code: string;
    shortName?: string;
}
export interface ITeamScore {
    home: number;
    away: number;
}
export interface IScore {
    total?: ITeamScore;
    halfTime?: ITeamScore | null;
    regularTime?: ITeamScore | null;
    extraTime?: ITeamScore | null;
    penaltyShootout?: ITeamScore | null;
    aggregate?: ITeamScore | null;
    display?: ITeamScore | null;
    afterExtraTime?: ITeamScore | null;
}
export interface IReferee {
    id: string;
    name: string;
    role: string;
}
export interface IMinute {
    regularTime: number;
    injuryTime?: number | null;
}
export type ScoreType = 'runningscore' | 'finalresult' | 'quarter1' | 'quarter2' | 'quarter3' | 'quarter4' | 'overtime' | 'period1' | 'period2';
export interface Score {
    home?: number;
    away?: number;
}
export interface IMatch {
    id: string;
    slug: string;
    kickoffTime?: string;
    stage?: IStage;
    season?: ISeason;
    homeTeam: ITeam;
    awayTeam: ITeam;
    coverage?: string;
    status?: IStatus;
    round?: IRound;
    venue?: IVenue;
    score?: IScore & {
        [key in ScoreType]: Score;
    };
    referees?: IReferee[];
    minute?: IMinute;
    winner?: IWinner;
    tournament?: ITournament;
    spectators?: number;
    group?: IGroup;
    mainEvents?: IMainEvent[];
    lineupsStatus?: LineupStatuses;
    penalty_shootout_events?: IMainEvent[] | null;
    penalty_shootout_events_section?: {
        [teamId: string]: boolean[];
    };
}
export interface IMainEvent {
    id: string | null;
    matchId: string | null;
    minute: number | null;
    injuryMinute: number | null;
    teamId: string | null;
    teamPosition: string | null;
    typeCode: string | null;
    score: ITeamScore | null;
    primaryPlayer: IMainEventParticipant | null;
    secondaryPlayer: IMainEventParticipant | null;
}
export interface IMainEventParticipant {
    id: string | null;
    name: string | null;
    position: string | null;
    type: string | null;
}
interface IGroup {
    id: string;
    name: string;
    slug: string;
}
export interface IWinner {
    match?: {
        id: string;
        reason?: {
            name?: 'pen' | null;
        } | null;
    } | null;
    aggregate?: {
        id: string;
        reason?: {
            name?: 'agg' | null;
        } | null;
    } | null;
}
export interface IFootballTournamentMatch {
    info: IMatch;
    odds?: IOddsV2;
}
export type WidgetAttributes = {
    required: string[];
    optional: string[];
    all: string[];
    mapped: IDictionary<string>;
};
export interface ITournamentStanding {
    id: number;
    name: string;
    tournamentId: number;
    tournamentSeasonId: number;
    country: ICountry;
    cup: boolean;
    live: boolean;
    endDate: string;
    startDate: string;
    standing?: IStanding[];
    groups?: ITournamentGroup[];
}
export interface ITournamentGroup {
    id?: number;
    name: string;
    standing?: IStanding[];
}
export interface IStanding {
    rank: number;
    team: ITournamentTeam;
    wins: number;
    draws: number;
    played: number;
    points: number;
    defeits: number;
    goalsFor: number;
    goalsAgainst: number;
    rules: IRule[];
}
export interface ITournamentTeam extends ITeam {
    form: IForm[];
}
export interface IForm {
    outcome: string;
    event: IEvent;
}
export interface IStandingsForm {
    outcome: string;
    result: IResult[];
    participants: ITeam[];
    startTime: string;
    id: string;
    slug: string;
}
export interface IStandingsTeamForm {
    outcome: string;
    result: IResult[];
    participants: ITeam[];
    start_time: string;
    id: string;
    slug: string;
}
export interface IResult {
    type: string;
    results: IResultItem[];
}
export interface IResultItem {
    value: string;
    position: string;
}
export interface IEvent {
    id: number;
    slug: string;
    eventStatus: IStatus;
    homeTeam: ITeam;
    awayTeam: ITeam;
    startTime: string;
    round: string;
    goalHome: number;
    goalAway: number;
}
export interface IRule {
    name: string;
    code?: string;
    type: string;
    id: string;
}
export type RuleType = 'none' | 'top' | 'topplayoff' | 'tiertwo' | 'tiertwoplayoff' | 'relegation' | 'relegationplayoff' | 'promotion' | 'promotionplayoff' | 'championshipplayoff';
export declare enum LineupStatuses {
    NOT_AVAILABLE = "NOT_AVAILABLE",
    UNCONFIRMED = "UNCONFIRMED",
    CONFIRMED = "CONFIRMED"
}
export interface IStandingsDataLabels extends IDictionary<string | undefined> {
    team?: string;
    team_form_short?: string;
    team_form?: string;
    matches_played_short?: string;
    matches_won_short?: string;
    matches_won_overtime_short?: string;
    match_draws?: string;
    match_losses_short?: string;
    matches_losses_overtime?: string;
    goal_difference_short?: string;
    points_difference?: string;
    group?: string;
    points_short?: string;
    percentages?: string;
    matches_played?: string;
    matches_won?: string;
    matches_won_overtime?: string;
    match_draw?: string;
    match_losses?: string;
    match_losses_overtime?: string;
    goal_difference?: string;
    points?: string;
    footer_win?: string;
    footer_draw?: string;
    footer_loss?: string;
    no_data?: string;
    no_games?: string;
    win_after_penalty_short?: string;
    loss_after_penalty_short?: string;
    win_overtime_short?: string;
    loss_overtime_short?: string;
}
export interface IKnockoutDataLabels extends IDictionary<string | undefined> {
    no_matches?: string;
}
export interface ITeamSquadLabels extends IDictionary<string | undefined> {
    name?: string;
    age_short?: string;
    played_short?: string;
    minutes_short?: string;
    yellow_cards_short?: string;
    red_cards_short?: string;
    age?: string;
    played?: string;
    minutes?: string;
    yellow_cards?: string;
    red_cards?: string;
    goalkeepers?: string;
    defenders?: string;
    midfielders?: string;
    forwards?: string;
    goals_short?: string;
    assists_short?: string;
    minutes_substitute_short?: string;
    started_short?: string;
    conceded_short?: string;
    cleansheets_short?: string;
    goals?: string;
    assists?: string;
    minutes_substitute?: string;
    started?: string;
    conceded?: string;
    cleansheets?: string;
    list_view?: string;
    card_view?: string;
}
export interface IFansUnitedDataLabels extends IDictionary<string | undefined> {
    fu_win_question?: string;
    fu_draw?: string;
    fu_play_free?: string;
    follow?: string;
    followed?: string;
    followers?: string;
}
export interface IProgramDataLabels extends IDictionary<string | undefined> {
    current_season?: string;
    fixtures?: string;
    results?: string;
    round?: string;
}
export interface IMatchesH2HDataLabels extends IDictionary<string | undefined> {
    H2H?: string;
    W?: string;
    L?: string;
    D?: string;
}
export interface IHeadLabel {
    value: string;
    css?: CSS;
    tooltip?: string;
    statValue?: string;
}
export interface IMostDecoratedDataLabels extends IDictionary<string | undefined> {
    first_yellow_cards_short?: string;
    player?: string;
    first_yellow_cards?: string;
    total_cards_short?: string;
    total_cards?: string;
    red_cards_short?: string;
    red_cards?: string;
    yellow_cards_short?: string;
    yellow_cards?: string;
    name?: string;
}
export declare enum IMostDecoratedDataLabelsKeys {
    FIRST_YELLOW_CARDS = "first_yellow_cards",
    RED_CARDS = "red_cards",
    TOTAL_CARDS = "total_cards",
    YELLOW_CARDS = "yellow_cards"
}
export interface IPlayerDataLabels extends IDictionary<string | undefined> {
    played?: string;
    goals?: string;
    assists?: string;
    fouls_committed?: string;
    shots?: string;
    shots_on_target?: string;
    FORWARD?: string;
    MIDFIELDER?: string;
    DEFENDER?: string;
    KEEPER?: string;
    weight_metric?: string;
    height_metric?: string;
    follow?: string;
    followed?: string;
    followers?: string;
}
export interface ISingleEventDataLabels extends IDictionary<string | undefined> {
    round?: string;
    in_regular_time?: string;
    after_penalties?: string;
    aggregate?: string;
    own_goal?: string;
    penalty_goal?: string;
}
export interface ITabs extends IDictionary<string | undefined> {
    [type: string]: string;
}
export type INormalizedMatchData = {
    id: string;
    kickoffTime?: string;
    homeTeam: {
        name: string;
        logo: string;
        id: string | number;
        url: string;
    };
    awayTeam: {
        name: string;
        logo: string;
        id: string | number;
        url: string;
    };
    status?: string;
    minute?: IMinute | null;
    matchLink?: string;
    date: string;
    matchStatus?: IStatus;
    homeTeamScore: number | string;
    awayTeamScore: number | string;
    urlTarget?: string;
    score?: IScore;
    winnerReason?: WinnerReason | null;
};
export type INormalizedTournamentData = {
    id: string;
    name: string;
    slug: string | null;
    country: ICountry;
    gender?: string;
    type: string;
    region: string;
    assets: IAssets | null;
    stage?: IStage;
    round?: IRound;
    seasons?: ISeason[];
    regionalLeague?: boolean;
    logo?: string;
    urlTarget?: string;
    tournamentImage?: string;
    tournamentLink?: string;
    standingsLink?: string;
    isDomesticLeague?: boolean;
    isDomestic?: boolean;
    hasMultipleStages?: boolean;
    season?: string;
};
export type INormalizedOdd = {
    oddProvider: {
        name: string | undefined;
        logo: IAssetsEntity | undefined;
        url: string | undefined;
        id: number | undefined;
        entityType: string;
    };
    '1x2': {
        '1': {
            odds: any;
            url?: string;
        };
        '2': {
            odds: any;
            url?: string;
        };
    };
};
export interface INormalizedStandingsGroup {
    name?: string;
    item?: INormalizedStandings;
    desktopColumn?: IHeadLabel[];
    mobileColumn?: IHeadLabel[];
    position?: string;
}
export interface INormalizedKnockoutData {
    hasSmallFinal: boolean;
    smallFinalName?: string;
    data: 0 | {
        name: string;
        groups: (INormalizedKnockoutGroup | undefined)[] | undefined;
    }[];
}
export interface INormalizedKnockout {
    name: string;
    status: string;
    groups: (INormalizedKnockoutGroup | undefined)[] | undefined;
}
export type SportType = 'football' | 'basketball' | 'tennis' | 'ice-hockey';
export type RankingType = 'points' | 'percentage';
export interface INormalizedStandings {
    data?: INormalizedStanding[];
    rankingType?: RankingType;
    desktopColumns: IHeadLabel[];
    mobileColumns: IHeadLabel[];
}
export interface INormalizedStanding {
    isHighlighted?: boolean;
    ruleType?: RuleType;
    desktopColumns?: INormalizedStandingColumn[];
    mobileColumns?: INormalizedStandingColumn[];
}
export interface INormalizedStandingColumn {
    value: string | number | INormalizedTeamForm[];
    type: string;
    link?: string;
    urlTarget?: string;
    alt?: string;
    eventValues?: {
        id?: string | number;
        name?: string;
    };
    css?: CSS;
    countryName?: string;
    countryFlag?: string;
    teamName?: string;
    teamId?: string;
    teamLink?: string;
    teamLogo?: string;
}
export interface INormalizedPlayer {
    thumb: string;
    id: string | number;
    image: string;
    name: string;
    position: string;
    birthdate: string;
    profile?: {
        height?: string;
        weight?: string;
    };
    age?: number;
    country: {
        name: string;
        id: string;
        logo?: string | null;
    };
    url: string;
    urlTarget: string;
}
export interface INormalizedPlayerData {
    match?: INormalizedMatchData;
    player: INormalizedPlayer;
    season: {
        id: string;
        name: string;
        status: string;
        tournament?: INormalizedTournamentData;
    };
    statistics: IStatistic[];
    teams: INormalizedTeam;
}
export interface INormalizedTeamData {
    match?: INormalizedMatchData;
    statistics: IStatistic[];
    team: INormalizedTeam;
    tournament?: INormalizedTournamentData;
    season: {
        id: string;
        name: string;
        active: boolean;
    };
}
export interface INormalizedTeam {
    id: string | number;
    logo: string;
    name: string;
    url: string;
    national?: boolean;
    urlTarget: string;
    founded?: number;
    venue?: string;
    country?: {
        name?: string;
        id?: string;
        logo?: string;
    };
    type?: string;
    socials?: {
        twitterId?: string;
        facebookId?: string;
        instagramId?: string;
        web?: string;
        youtubeChannelId?: string;
        wikipediaId?: string;
    };
}
export interface INormalizedKnockoutGroup {
    id: string;
    childObjectId: string;
    order: number;
    matches: (INormalizedKnockoutMatch | undefined)[];
    teams: (INormalizedKnockoutTeam | undefined)[];
    homeTeamName?: string;
    awayTeamName?: string;
    totalScoreHomeTeamFirstMatch: number | string;
    totalScoreAwayTeamFirstMatch: number | string;
    totalScoreHomeTeamSecondMatch: number | string;
    totalScoreAwayTeamSecondMatch: number | string;
    urlTarget: string;
    matchLink?: string;
}
export interface INormalizedKnockoutTeam {
    id: string | number;
    name: string;
    logo: string;
    url: string;
    winner?: ITeam['winner'];
}
export interface INormalizedKnockoutMatch {
    id?: string | number;
    awayTeamId?: string;
    homeTeamId?: string;
    kickOffTime?: string;
    displayScore?: {
        home?: number;
        away?: number;
    };
    halfTimeScore?: {
        home?: number;
        away?: number;
    };
    regularTimeScore?: {
        home?: number;
        away?: number;
    };
    aggregateScore?: {
        home?: number;
        away?: number;
    };
    penaltyShootoutScore?: {
        home?: number;
        away?: number;
    };
    winnerTeamId?: string;
    winnerTeamName?: string;
    winnerTeamLogo?: string;
    matchLink?: string;
    winner?: IWinner;
    statusType?: string;
}
export interface INormalizedTeamForm {
    matchLink: string;
    startTime: string;
    outcome: string;
    matchSummary: string;
    urlTarget: string;
    matchId: string | number;
}
export interface INormalizedRoundData {
    name: string;
    key: string;
    type: string;
}
export interface IKnockout {
    name: string;
    status: string;
    groups: IKnockoutGroup[];
}
export interface IKnockoutGroup {
    id: string;
    order: number;
    childObjectId: string;
    matches: IKnockoutMatch[];
    teams: ITeam[];
}
export interface IKnockoutMatch {
    id: string;
    slug: string;
    away_team_id: string;
    home_team_id: string;
    kickoff_time: string;
    score: IScore;
    winner?: IWinner;
    status_type: string;
}
export interface ILivescoreDataLabels extends IDictionary<string | undefined> {
    all?: string;
    popular?: string;
    upcoming?: string;
    live?: string;
    finished?: string;
}
export interface ITournamentProps {
    tournament?: INormalizedTournamentData;
    handleTournamentClick: (tournament: ITournament) => void;
    sport?: SportType;
}
export type FansUnitedEnv = 'dev' | 'staging' | 'prod';
export type FansUnitedLang = 'en' | 'bg' | 'ro';
export type FansUnitedSchema = 'native' | 'enetpulse' | 'sportradar' | 'sportal365';
export type FansUnitedMarkets = 'FT_1X2';
export interface IFansUnitedAuth {
    getIdToken: () => string;
    logout: () => void;
}
export interface FansUnitedSDKOptions {
    apiKey: string;
    environment?: FansUnitedEnv;
    clientId: string;
    token?: string;
    lang?: FansUnitedLang;
    idSchema?: FansUnitedSchema;
    authProvider: IFansUnitedAuth;
    errorHandlingMode?: 'standard' | 'silent';
}
export type FansUnitedConfig = {
    fansUnitedMarket: FansUnitedMarkets;
    fansUnitedExpanded?: boolean;
    fansUnitedEnabled?: boolean;
    fansUnitedEnvironment?: FansUnitedEnv;
    fansUnitedHideBeforeGameStart?: number;
    fansUnitedShowFrom?: string;
    fansUnitedIdSchema?: FansUnitedSchema;
    fansUnitedApiKey?: string;
    fansUnitedClientId?: string;
};
export type FansUnitedInterestType = 'team' | 'player' | 'competition' | 'sport';
export interface IFansUnitedInterest {
    id: string;
    source: string;
    type: FansUnitedInterestType;
    favourite: boolean;
}
export interface IFansUnitedProfileOperations {
    showInterests: () => Promise<IFansUnitedInterest[]>;
    addInterest: (interest: Omit<IFansUnitedInterest, 'favourite'> & {
        favourite?: boolean;
    }) => IFansUnitedProfileOperations;
    removeInterest: (interest: Omit<IFansUnitedInterest, 'favourite'>) => IFansUnitedProfileOperations;
    update: () => Promise<unknown>;
}
export interface IFansUnitedProfile {
    getOwn: () => IFansUnitedProfileOperations;
    getById: (userId: string) => IFansUnitedProfileOperations;
}
export declare enum FansUnitedFilterKeys {
    FOOTBALL_TEAMS = "footballTeams",
    FOOTBALL_PLAYERS = "footballPlayers",
    FOOTBALL_COMPETITIONS = "footballCompetitions"
}
export interface IEntitiesFollowsFilters {
    footballCompetitions?: string[];
    footballTeams?: string[];
    footballPlayers?: string[];
}
export interface IEntityFollowBreakdown {
    id: string;
    count: number;
    model?: unknown;
}
export interface IEntitiesFollowsResponse {
    breakdown: IEntityFollowBreakdown[];
    total: number;
}
export interface IFansUnitedLoyalty {
    getEntitiesFollows: (filters: IEntitiesFollowsFilters, disableCache?: boolean) => Promise<IEntitiesFollowsResponse>;
}
export interface IFansUnitedSDKVersion {
    version: string;
    major: number;
    minor: number;
    patch: number;
}
export interface IFansUnitedSDK {
    version?: string;
    VERSION?: string;
    getVersion?: () => string | IFansUnitedSDKVersion;
    profile: IFansUnitedProfile;
    loyalty?: IFansUnitedLoyalty;
}
export type OneXTwo = '1' | 'x' | '2';
export interface IPredictionResponse {
    id: string;
    gameInstanceId: string;
    gameType: string;
    wager: unknown;
    totalFixtures: number;
    settledFixtures: number;
    userId: string;
    fixtures: IFuFixture[];
    status: string;
    tiebreaker: unknown;
    points: number;
    createdAt: string;
    updatedAt: string;
}
export interface IFuFixture {
    market: string;
    matchId: string;
    matchType: string;
    matchModel: IFuMatch;
    prediction: IFuPrediction;
    result: IFuResult;
}
export interface IFuMatch {
    id: string;
    kickoffAt: string;
    finishedAt: string;
    updatedAt: string;
    homeTeam: IFuTeam;
    awayTeam: IFuTeam;
    lineupsConfirmed: boolean;
    startedAt: string;
    minute: string | number;
    scores: IFuScores;
    context: IFuContext;
    status: IFuStatus;
}
export interface IFuTeam {
    id: string;
    country: IFuCountry;
    gender: string;
    assets: IFuAssets;
    name: string;
    code: string;
    national: boolean;
    fullName: string;
    shortName: string;
}
export interface IFuCountry {
    id: string;
    alias: string;
    countryCode: string;
    assets: IFuAssets;
    name: string;
}
export interface IFuAssets {
    flag: string;
}
export interface IFuScores {
    ftScore: IFuScore;
    htScore: IFuScore;
    aetScore: IFuScore;
    aggScore: IFuScore;
    penScore: IFuScore;
}
export interface IFuScore {
    homeGoals: string | number;
    awayGoals: string | number;
}
export interface IFuContext {
    competition: IFuCompetition;
}
export interface IFuCompetition {
    id: string;
    country: IFuCountry;
    gender: string;
    assets: IFuAssets;
    type: string;
    name: string;
}
export interface IFuStatus {
    type: string;
    subType: string;
}
export interface IFuPrediction {
    value: OneXTwo | null;
    playerId: string;
    playerModel: unknown;
}
export interface IFuResult {
    settledAt: string;
    resettledAt: string;
    status: string;
    outcome: string;
    points: number;
}
export interface IMarketSummaryResponse {
    matchId: string;
    matchType: string;
    fullTimeOneXTwo: IFullTimeOneXTwo;
}
export interface IFullTimeOneXTwo {
    '1': number;
    '2': number;
    x: number;
}
export interface IShowMoreLabel {
    show_more: string;
}
export interface ITopScorersDataLabels extends IDictionary<string | undefined> {
    assists_short?: string;
    goals_short?: string;
    player?: string;
    minutes_short?: string;
    penalties_short?: string;
    played_short?: string;
    red_cards_short?: string;
    scored_first_short?: string;
    yellow_cards_short?: string;
    missed_penalties_short?: string;
    assists?: string;
    goals?: string;
    minutes?: string;
    penalties?: string;
    played?: string;
    red_cards?: string;
    scored_first?: string;
    yellow_cards?: string;
    missed_penalties?: string;
    name?: string;
}
export declare enum ITopScorersDataLabelsKeys {
    ASSISTS = "assists",
    GOALS = "goals",
    MINUTES = "minutes",
    PENALTIES = "penalties",
    PLAYED = "played",
    RED_CARDS = "red_cards",
    SCORED_FIRST = "scored_first",
    YELLOW_CARDS = "yellow_cards",
    MISSED_PENALTIES = "missed_penalties"
}
export interface ISportEntity {
    id: string;
    seasonId: ISeason['id'];
}
export type ILabels = Record<string, string | undefined>;
export type IElements = string[] | {
    info?: string[];
    stats?: string[] | Record<string, string[]>;
};
export type IPlayerDataElements = {
    stats?: string[];
};
export type IHighlightEntities = string[];
export declare enum Movement {
    UP = "UP",
    DOWN = "DOWN",
    NONE = "NONE"
}
export type IOddsFromSingleProvider = OddsModel;
export type IOddsV2 = IOddsFromSingleProvider[];
export declare enum OddsMarketTypes {
    ONETWO = "12",
    ONEXTWO = "1x2",
    OVER_UNDER = "OVER_UNDER",
    DOUBLE_CHANCE = "DOUBLE_CHANCE",
    BOTH_TO_SCORE = "BOTH_TO_SCORE",
    DRAW_NO_BET = "DRAW_NO_BET",
    FIRST_TEAM_TO_SCORE = "FIRST_TEAM_TO_SCORE",
    GAME_HANDICAP = "GAME_HANDICAP",
    FIRST_HALF = "FIRST_HALF",
    SECOND_HALF = "SECOND_HALF",
    FULL_TIME = "FULL_TIME",
    FIRST_HALF_GOALS = "FIRST_HALF_GOALS",
    CORRECT_SCORE = "CORRECT_SCORE",
    FIRST_PLAYER_TO_SCORE = "FIRST_PLAYER_TO_SCORE",
    PLAYER_TO_SCORE_DURING_GAME = "PLAYER_TO_SCORE_DURING_GAME",
    PLAYER_TO_RECEIVE_CARD = "PLAYER_TO_RECEIVE_CARD",
    FIRST_HALF_AND_FINAL_RESULT = "FIRST_HALF_AND_FINAL_RESULT"
}
export type OddsMarketScope = OddsMarketTypes.FIRST_HALF | OddsMarketTypes.SECOND_HALF | OddsMarketTypes.FULL_TIME;
export declare enum OddFormat {
    FRACTIONAL = "FRACTIONAL",
    DECIMAL = "DECIMAL",
    MONEYLINE = "MONEYLINE"
}
export declare enum OddsTypes {
    PRE_EVENT = "PRE_EVENT",
    ALL = "ALL"
}
export declare enum OptionalData {
    STANDINGS = "STANDINGS"
}
export type INormalizedFootballGameData = {
    id: string;
    homeTeam: Pick<INormalizedTeam, 'name' | 'logo' | 'id' | 'url' | 'type' | 'national'>;
    awayTeam: Pick<INormalizedTeam, 'name' | 'logo' | 'id' | 'url' | 'type' | 'national'>;
    date?: [boolean, string];
    status?: string;
    homeTeamScore: string | number;
    awayTeamScore: string | number;
    matchStatus?: IStatus | null;
    kickOffTime?: Date;
    minute?: IMinute | null;
    matchLink: string;
    urlTarget: string;
    winnerId?: string;
    aggregateWinnerId?: string | null;
    winnerReason: WinnerReason | null;
};
export type MatchContainerTypes = 'livescore' | 'singleEvent';
export type WidgetsIdTypes = TennisWidgetType | BasketballWidgetType | string;
export type WidgetContextProps = {
    widgetId: WidgetsIdTypes;
    widgetSport: SportType;
    widgetCuid: string;
};
type SMPWidgetOddsByCuid = Record<string, number>;
type SMPWidgetOddsByWidgetId = Record<string, SMPWidgetOddsByCuid>;
type SMPWidgetOddsBySport = Record<string, SMPWidgetOddsByWidgetId>;
interface SMPWidgetOdds {
    [sport: string]: SMPWidgetOddsBySport;
}
export interface CustomWindow extends Window {
    smpWidgetsOdds: SMPWidgetOdds;
}
export declare enum HeaderLabels {
    OVERTIME = "overtime_short",
    POINTS = "points_short",
    SCORE = "score_short"
}
export interface IStakesDataLabels {
    stakes_amount_description?: string;
    stakes_bet?: string;
    stakes_bet_on_team?: string;
    stakes_currency?: string;
    stakes_payout?: string;
    stakes_stake?: string;
    stakes_invalid_stake?: string;
    stakes_limit_exceeded?: string;
    vs?: string;
    round?: string;
}
export type CurrencyPosition = 'prefix' | 'suffix';
export declare enum SocialLabels {
    FACEBOOK = "facebook",
    TWITTER = "twitter",
    YOUTUBE = "youtube",
    WIKIPEDIA = "wikipedia",
    WEB = "web",
    INSTAGRAM = "instagram"
}
export type OptionsDisplay = 'auto' | true | false;
export declare enum ParticipantType {
    HOME = "HOME",
    AWAY = "AWAY"
}
export declare enum TeamFormOutcomeTypes {
    WIN = "win",
    LOSS = "loss",
    WIN_OVERTIME = "win_overtime",
    LOSS_OVERTIME = "loss_overtime",
    DRAW = "draw",
    WIN_AFTER_PENALTY = "win_after_penalty",
    LOSS_AFTER_PENALTY = "loss_after_penalty"
}
export interface IOddsBaseConfig {
    dataOddsDisplay?: boolean;
    dataOddsMarketValueType?: OddMarketValueTypes;
    dataOddsMarket?: Markets;
    dataOddsBettingId?: string | null;
    dataOddsPreEventOnly?: boolean;
}
export interface INormalizedCompetition {
    id: string;
    title: string;
    slug: string;
    target: string;
    subTitle: string;
    competitionLogo: string;
    competitionUrl: string;
    standingsLabel: string;
    standingsUrl: string;
    isCountryLogo?: boolean;
}
export declare enum TeamTypes {
    HOME = "home",
    AWAY = "away"
}
export interface IHeaderTableColumnLabels {
    full?: string;
    short?: string;
    key: string;
}
export {};