import * as React$1 from 'react';
import React__default, { FC } from 'react';
import { W as WidgetStyle, P as Positions, a as WidgetComboType$1, C as CtaPosition } from './WidgetStylePayload-BELXQ9Zl.js';
export { B as BaseStyle, I as IDENTITY_FIELDS, b as PAYLOAD_FIELDS, R as ROUTING_FIELDS, S as StyleOverrides, c as WIDGET_STYLE_SCHEMA_VERSION, d as WidgetComboKey, e as WidgetKey, f as WidgetStylePayload, g as WidgetType, t as toPayload } from './WidgetStylePayload-BELXQ9Zl.js';

interface LangDropdownProps {
    selected: string | string[];
    onSelect: (lang: string) => void;
    multiple?: boolean;
}

interface BrandedButtonStyle {
    backgroundColor: string;
    border: string;
    color: string;
    boxShadow: string;
    borderRadius: string;
    fontSize: string;
    fontWeight: string;
}

type TabItem = {
    id: string;
    label: React__default.ReactNode;
    content: React__default.ReactNode;
    disabled?: boolean;
};
type TabsProps = {
    items: TabItem[];
    defaultActiveId?: string;
    activeId?: string;
    onChange?: (id: string) => void;
    onActivePanelHeight?: (h: number) => void;
    containerStyle?: React__default.CSSProperties;
    listStyle?: React__default.CSSProperties;
    tabStyle?: React__default.CSSProperties;
    tabActiveStyle?: React__default.CSSProperties;
    tabDisabledStyle?: React__default.CSSProperties;
    panelStyle?: React__default.CSSProperties;
    indicatorStyle?: React__default.CSSProperties;
    ariaLabel?: string;
};
declare function Tabs({ items, defaultActiveId, activeId, onChange, onActivePanelHeight, // <-- NEW
containerStyle, listStyle, tabStyle, tabActiveStyle, tabDisabledStyle, panelStyle, indicatorStyle, ariaLabel, }: TabsProps): React__default.JSX.Element;

type BrandedProps = {
    style: WidgetStyle;
    children: React__default.ReactNode;
};
declare const Branded: (({ style, children }: BrandedProps) => React__default.JSX.Element) & {
    WidgetContainer: React__default.ForwardRefExoticComponent<{
        children: React__default.ReactNode;
        widgetName: keyof Positions;
        size?: "full" | "screen";
        hideCta?: boolean;
    } & React__default.RefAttributes<HTMLDivElement>>;
    ScrollContainer: React__default.ForwardRefExoticComponent<{
        style?: React__default.CSSProperties;
        className?: string;
        children: React__default.ReactNode;
    } & React__default.RefAttributes<HTMLDivElement>>;
    Dropdown: React__default.FC<{
        label: React__default.ReactNode | string;
        items: ({
            content: React__default.ReactNode | string;
            value: string | number;
        } & {
            label: string;
        })[];
        selected: string | number | (string | number)[];
        onSelect: (value: string | number) => void;
        multiple?: boolean;
        searchable: true;
        searchPlaceholder?: string;
    } | {
        label: React__default.ReactNode | string;
        items: {
            content: React__default.ReactNode | string;
            value: string | number;
        }[];
        selected: string | number | (string | number)[];
        onSelect: (value: string | number) => void;
        multiple?: boolean;
        searchable?: false;
        searchPlaceholder?: string;
    }>;
    CurrencyDropdown: {
        ({ label, currencies, selected, onSelect, multiple, }: {
            label: string;
            currencies: string[];
            selected: string | string[];
            onSelect: (currency: string) => void;
            multiple?: boolean;
        }): React__default.JSX.Element;
        displayName: string;
    };
    PairDropdown: {
        ({ currencies, onSelect, }: {
            currencies: string[];
            onSelect: (pair: string[]) => void;
        }): React__default.JSX.Element;
        displayName: string;
    };
    TextInput: {
        ({ type, value, onChange, min, max, placeholder, }: {
            type?: "number";
            value?: string | number;
            onChange: (e: React__default.ChangeEvent<HTMLInputElement>) => void;
            min?: number;
            max?: number;
            placeholder?: string;
        }): React__default.JSX.Element;
        displayName: string;
    };
    Button: React__default.FC<{
        brandedStyle: BrandedButtonStyle;
    } & React__default.ButtonHTMLAttributes<HTMLButtonElement>>;
    ButtonGroup: {
        ({ items, selected, }: {
            items: {
                label: string;
                onClick: () => void;
            }[];
            selected?: string;
        }): React__default.JSX.Element;
        displayName: string;
    };
    Label: {
        ({ children, for: htmlFor, customStyle, }: {
            children: React__default.ReactNode;
            for?: string;
            customStyle?: React__default.CSSProperties;
        }): React__default.JSX.Element;
        displayName: string;
    };
    ResultsContainer: {
        ({ children, customStyle, }: {
            children: React__default.ReactNode;
            customStyle?: React__default.CSSProperties;
        }): React__default.JSX.Element;
        displayName: string;
    };
    Table: React__default.FC<{
        children: React__default.ReactNode;
    }> & {
        Head: React__default.FC<{
            children: React__default.ReactNode;
        }>;
        HeadCell: React__default.FC<{
            children: React__default.ReactNode;
        }>;
        Body: React__default.FC<{
            children: React__default.ReactNode;
        }>;
        Row: React__default.FC<{
            children: React__default.ReactNode;
            index?: number;
            isLastRow?: boolean;
            customStyle?: React__default.CSSProperties;
        }>;
        Cell: React__default.FC<{
            children: React__default.ReactNode;
            className?: string;
            customStyle?: React__default.CSSProperties;
            headLike?: boolean;
            isLastCol?: boolean;
            isLastRow?: boolean;
            colSpan?: number;
        }>;
        displayName?: string;
    };
    DateRangePicker: {
        ({ value, onChange, }: {
            value: EcoCal.StringDateRange;
            onChange?: (value: EcoCal.StringDateRange) => void;
        }): React__default.JSX.Element;
        displayName: string;
    };
    LangDropdown: React__default.FC<LangDropdownProps>;
    Tabs: typeof Tabs;
};

interface EconomicCalendarProps {
    styles: WidgetStyle;
    size?: "full" | "screen";
}
declare function EconomicCalendar({ styles, size, }: EconomicCalendarProps): JSX.Element;

type HeatmapPeriodOption = '15m' | '60m' | '240m' | '1d' | '1w' | '1M';

interface CurrencyConverterDictionary {
    title: string;
    from: string;
    to: string;
    amount: string;
    convert: string;
    result: string;
}
interface FibonacciDictionary {
    title: string;
    uptrend: string;
    downtrend: string;
    high: string;
    low: string;
    retracements: string;
    extensions: string;
    values: string;
    result: string;
}
interface MarginCalculatorDictionary {
    title: string;
    leverage: string;
    lotSize: string;
    accountCurrency: string;
    currencyPair: string;
    accountType: string;
    price: string;
    requiredMargin: string;
    result: string;
}
interface PivotsDictionary {
    title: string;
    classic: string;
    woodie: string;
    camarilla: string;
    demark: string;
    high: string;
    low: string;
    open: string;
    close: string;
    pivotPoints: string;
    "res-4": string;
    "res-3": string;
    "res-2": string;
    "res-1": string;
    pivot: string;
    "sup-1": string;
    "sup-2": string;
    "sup-3": string;
    "sup-4": string;
    result: string;
}
interface StopLossTakeProfitDictionary {
    title: string;
    buy: string;
    sell: string;
    lots: string;
    stop: string;
    Limit: string;
    maxLoss: string;
    maxProfit: string;
    result: string;
}
interface StopLossTakeProfitLevelsDictionary {
    title: string;
    open: string;
    value: string;
    lots: string;
    risk: string;
    gain: string;
    stopLoss: string;
    takeProfit: string;
    stopLossPips: string;
    takeProfitPips: string;
    result: string;
}
interface HeatmapDictionary {
    title: string;
    currencies: string;
    value: string;
    result: string;
    periods: HeatmapPeriodsT;
    tooManyCurrencies: string;
}
interface EconomicCalendarDictionary {
    title: string;
    impact: string;
    high: string;
    medium: string;
    low: string;
    countries: string;
    customRange: string;
    yesterday: string;
    today: string;
    tomorrow: string;
    thisWeek: string;
    lastWeek: string;
    nextWeek: string;
    noEventsFound: string;
    event: string;
    actual: string;
    forecast: string;
    previous: string;
    holaPrime: {
        columns: {
            time: string;
            news: string;
            impact: string;
            impactedCurrency: string;
            actual: string;
            forecast: string;
            prior: string;
            impactedInstruments: string;
        };
        dateRangePicker: {
            customDates: string;
            selectDateRange: string;
            startDate: string;
            endDate: string;
            apply: string;
        };
        andMore: string;
        stocks: {
            splits: string;
            earnings: string;
            dividends: string;
            stockSplit: string;
            dividend: string;
            epsActual: string;
            epsForecast: string;
            revenueActual: string;
            revenueForecast: string;
            exDate: string;
            cycle: string;
            payment: string;
            yield: string;
            ratio: string;
        };
    };
}
interface SignalsDictionary {
    title: string;
    support: string;
    resistance: string;
}
interface GlossaryDictionary {
    searchPlaceholder: string;
    noResults: string;
}
interface NewsDictionary {
    categories: {
        all: string;
        forex: string;
        stock: string;
        crypto: string;
        cmd: string;
        worldec: string;
        regec: string;
        latam?: string;
    };
    searchPlaceholder: string;
    searchLabel: string;
    articleCategoriesLabel: string;
    latestNews: string;
    noSearchResults: string;
    loading: string;
    loadMore: string;
    popularTopics: string;
    relatedNews: string;
    back: string;
    share: string;
    readingTime: string;
    liveUpdates: {
        latestAriaLabel: string;
        live: string;
        openFeed: string;
        resume: string;
        pause: string;
        title: string;
        viewAll: string;
        newestFirst: string;
        oldestFirst: string;
        sortOldestFirst: string;
        sortNewestFirst: string;
        newUpdate: string;
        newUpdates: string;
        loading: string;
        loadError: string;
        tryAgain: string;
        empty: string;
        latest: string;
        loadingEarlier: string;
        loadEarlier: string;
        backToNews: string;
    };
}
interface VideoNewsDictionary {
    eyebrow: string;
    title: string;
    description: string;
    cta: string;
    share: string;
    noVideo: string;
    copied: string;
    copyLink: string;
    shareOn: string;
}
interface TopMoversDictionary {
    title: string;
    active: string;
    gainers: string;
    losers: string;
    noData: string;
}
interface StockWidgetDictionary {
    periods: {
        "15m": string;
        "1h": string;
        "1d": string;
    };
    assets: {
        crudeOil: string;
        gold: string;
        silver: string;
    };
}
interface AnalystRecommendationsDictionary {
    title: string;
    strongSell: string;
    moderateSell: string;
    hold: string;
    moderateBuy: string;
    strongBuy: string;
    sell: string;
    buy: string;
    averageTarget: string;
    noData: string;
    loadError: string;
}
interface AssetOverviewDictionary {
    open: string;
    close: string;
    dayRange: string;
    volume: string;
    keyStatistics: string;
    performance: string;
    week1: string;
    month1: string;
    month3: string;
    ytd: string;
    analystConsensus: string;
    relatedNews: string;
    noData: string;
    loadError: string;
}
interface Dictionary {
    currencyConverter: CurrencyConverterDictionary;
    fibonacci: FibonacciDictionary;
    marginCalculator: MarginCalculatorDictionary;
    pivots: PivotsDictionary;
    stopLossTakeProfit: StopLossTakeProfitDictionary;
    stopLossTakeProfitLevels: StopLossTakeProfitLevelsDictionary;
    heatmap: HeatmapDictionary;
    economicCalendar: EconomicCalendarDictionary;
    signals: SignalsDictionary;
    glossary: GlossaryDictionary;
    news: NewsDictionary;
    videoNews: VideoNewsDictionary;
    topMovers: TopMoversDictionary;
    stockWidget: StockWidgetDictionary;
    analystRecommendations: AnalystRecommendationsDictionary;
    assetOverview: AssetOverviewDictionary;
}
type HeatmapPeriodT = {
    short: string;
    long: string;
};
type HeatmapPeriodsT = Record<HeatmapPeriodOption, HeatmapPeriodT>;

type SignalStyle = {
    background: string;
    textColor: string;
    borderWidth: string;
    borderColor: string;
    borderStyle: string;
    borderRadius: string;
    supportBackground: string;
    supportText: string;
    resistanceBackground: string;
    resistanceText: string;
};

type SignalsStyles = {
    signal: SignalStyle;
    fontFamily: string;
    columnMode: boolean | null;
    singleAsset: boolean;
};
interface SignalsProps {
    styles: WidgetStyle;
    assets: {
        forex: number[];
        stock: number[];
    };
    inCombo?: WidgetComboType$1;
    size?: "full" | "screen";
}
declare function Signals({ styles, assets, inCombo, size, }: SignalsProps): React$1.JSX.Element;

interface Props$g {
    countries: {
        name: string;
        code: string;
    }[];
    dev?: boolean;
    stocksEnabled?: boolean;
}
declare function HolaPrimeEconomicCalendar({ countries, dev, stocksEnabled, }: Props$g): JSX.Element;

type Props$f = {
    countries: {
        name: string;
        code: string;
    }[];
    dev?: boolean;
};
declare function HolaPrimeEconomicCalendarWithStocks(props: Props$f): React$1.JSX.Element;

interface AcademyWidgetStyle {
    header_image_exists: boolean;
    font_family: string;
    grid: {
        container: {
            backgroundColor: string;
            borderRadius: string;
            color: string;
        };
        header: {
            backgroundColor: string;
            borderRadius: string;
            color: string;
        };
        footer: {
            backgroundColor: string;
            borderRadius: string;
            color: string;
        };
        tile: {
            backgroundColor: string;
            borderRadius: string;
            borderColor: string;
            borderWidth: string;
            color: string;
            hover: {
                backgroundColor: string;
                color: string;
                borderColor: string;
                borderWidth: string;
            };
        };
        checkoutButton: {
            backgroundColor: string;
            color: string;
            borderRadius: string;
            borderColor: string;
            borderWidth: string;
            hover: {
                backgroundColor: string;
                color: string;
                borderColor: string;
            };
        };
    };
    chapter: {
        container: {
            backgroundColor: string;
            borderRadius: string;
            color: string;
        };
        header: {
            backgroundColor: string;
            borderRadius: string;
            borderColor: string;
            borderWidth: string;
            color: string;
        };
        navigationButton: {
            backgroundColor: string;
            color: string;
            borderRadius: string;
            borderColor: string;
            borderWidth: string;
            hover: {
                backgroundColor: string;
                borderColor: string;
            };
        };
        episodeListButton: {
            backgroundColor: string;
            color: string;
            borderRadius: string;
            borderColor: string;
            borderWidth: string;
            hover: {
                color: string;
                backgroundColor: string;
                borderColor: string;
                borderWidth: string;
            };
            active: {
                color: string;
                backgroundColor: string;
                borderColor: string;
                borderWidth: string;
            };
        };
        pdfModal: {
            content: {
                backgroundColor: string;
                color: string;
                borderColor: string;
                borderWidth: string;
                borderRadius: string;
            };
            closeButton: {
                backgroundColor: string;
                color: string;
                borderRadius: string;
                borderColor: string;
                borderWidth: string;
                hover: {
                    backgroundColor: string;
                    color: string;
                    borderColor: string;
                    borderWidth: string;
                };
            };
        };
    };
}
interface AcademyStyleMetadata {
    id: string;
    brand_id: number;
    brand_name: string;
    lang_code: string;
    name: string;
    is_active: boolean;
    status: 'draft' | 'published' | 'archived';
    schema_version: number;
    created_at?: string;
    updated_at?: string;
}
interface AcademyWidget extends AcademyStyleMetadata {
    payload: AcademyWidgetStyle;
}

interface AcademyEpisode {
    name: string;
    key: string;
    levelId: number;
    description: string;
}
interface AcademyChapter {
    name: string;
    episodes: AcademyEpisode[];
    levelId: number;
}
interface AcademyChaptersProps {
    data: AcademyWidget;
    dev?: boolean;
}
declare function AcademyChapters({ data, dev, }: AcademyChaptersProps): React$1.JSX.Element;

interface HeatmapProps {
    currencies: string[];
    styles: WidgetStyle;
    size?: "full" | "screen";
}
declare function Heatmap({ styles, currencies, size }: HeatmapProps): React$1.JSX.Element;

interface CurrencyConverterProps {
    styles: WidgetStyle;
    currencies: string[];
    size?: "full" | "screen";
}
declare function CurrencyConverter({ currencies, styles, size, }: CurrencyConverterProps): JSX.Element;

interface RawFibonacciProps {
    styles: WidgetStyle;
}
interface FibonacciProps extends RawFibonacciProps {
    size?: "full" | "screen";
}
declare function Fibonacci({ styles, size }: FibonacciProps): React$1.JSX.Element;

type AccountType = {
    id: number;
    value: number;
    label: string;
};

interface MarginCalculatorProps {
    styles: WidgetStyle;
    currencies: string[];
    accountTypes: AccountType[];
    size?: "full" | "screen";
}
declare function MarginCalculator({ styles, currencies, accountTypes, size, }: MarginCalculatorProps): React$1.JSX.Element;

interface PivotProps {
    styles: WidgetStyle;
    size?: "full" | "screen";
}
declare function Pivots({ styles, size }: PivotProps): React$1.JSX.Element;

interface StopLossTakeProfitProps {
    styles: WidgetStyle;
    size?: "full" | "screen";
}
declare function StopLossTakeProfit({ styles, size, }: StopLossTakeProfitProps): React$1.JSX.Element;

interface StopLossTakeProfitLevelsProps {
    styles: WidgetStyle;
    size?: "full" | "screen";
}
declare function StopLossTakeProfitLevels({ styles, size, }: StopLossTakeProfitLevelsProps): React$1.JSX.Element;

interface Props$e {
    styles: WidgetStyle;
    size?: "full" | "screen";
}
declare function Glossary({ styles, size }: Props$e): JSX.Element;

interface Props$d {
    styles: WidgetStyle;
    inCombo?: WidgetComboType$1;
    size?: "full" | "screen";
}
declare function News({ styles, size }: Props$d): JSX.Element;

interface Props$c {
    styles: WidgetStyle;
    size?: "full" | "screen";
    dev?: boolean;
}
declare function News2({ styles, size, dev }: Props$c): JSX.Element;

interface Props$b {
    styles: WidgetStyle;
    size?: "full" | "screen";
    dev?: boolean;
}
declare function News3({ styles, size, dev }: Props$b): JSX.Element;

interface Props$a {
    styles: WidgetStyle;
    size?: "full" | "screen";
    dev?: boolean;
}
declare function News4({ styles, size, dev }: Props$a): JSX.Element;

type Candle = {
    timestamp: number;
    open: number;
    high: number;
    low: number;
    close: number;
    volume?: number;
};
declare const CHART_TYPES: readonly ["candle", "area"];
type ChartType = (typeof CHART_TYPES)[number];
declare const STOCK_TIMEFRAMES: readonly ["15m", "1h", "1d"];
type StockTimeframe = (typeof STOCK_TIMEFRAMES)[number];
type ChartTheme = {
    up: string;
    down: string;
    background: string;
    grid: string;
    text: string;
    strong: string;
};

type StockAsset = {
    symbol: string;
    name: string;
    currency?: string;
    tabLabel?: string;
    /** FRED series key. Present => this is a macro series, not a tradable price. */
    macroSeries?: string;
};

interface Props$9 {
    styles: WidgetStyle;
    size?: "full" | "screen";
    onAssetSelect?: (asset: StockAsset) => void;
}
declare function LiveUpdates({ styles, size, onAssetSelect }: Props$9): React$1.JSX.Element;

interface Props$8 {
    styles: WidgetStyle;
    size?: "full" | "screen";
}
declare function VideoExplainer({ styles, size }: Props$8): JSX.Element;

type Props$7 = {
    styles: WidgetStyle;
    dev?: boolean;
    size?: "full" | "compact";
};
declare function VideoNews({ styles, dev, size }: Props$7): JSX.Element;

declare const SEGMENT_KINDS: readonly ["news", "tech", "econ"];
type SegmentKind = (typeof SEGMENT_KINDS)[number];
declare const TICKER_GROUPS: readonly ["forex", "index", "stock"];
type TickerGroup = (typeof TICKER_GROUPS)[number];
declare const TERM_SOURCES: readonly ["glossary", "event"];
type TermSource = (typeof TERM_SOURCES)[number];
declare const TERM_CATEGORIES: readonly ["inflation", "rates", "central-banks", "growth", "jobs", "fx", "commodities", "markets", "technicals"];
type TermCategory = (typeof TERM_CATEGORIES)[number];
interface DigestSegment {
    id: string;
    kind: SegmentKind;
    label: string;
    sub: string;
    script: string;
    startSec?: number;
}
interface DigestNumber {
    symbol: string;
    value: string;
    change: string;
    group: TickerGroup;
}
interface DigestLevels {
    symbol: string;
    s1: number;
    s2: number;
    r1: number;
    r2: number;
    indicatorLine: string;
}
interface DigestTerm {
    title: string;
    definition: string;
    source: TermSource;
    abbr?: string;
    category?: TermCategory;
    readItAs?: string;
}
interface DigestEvent {
    title: string;
    definition: string;
    dateUtc: string;
    previous: string;
    consensus: string;
    countryCode: string;
}
interface DigestStory {
    editionDateCode: string;
    headline: string;
    subHeadline: string;
}
interface Digest {
    brand: string;
    lang: string;
    editionDateCode: string;
    headline: string;
    subHeadline: string;
    channelKey: string | null;
    provider?: "streamvault";
    segments: DigestSegment[];
    numbers: DigestNumber[];
    levels: DigestLevels[];
    terms: DigestTerm[];
    upcoming: DigestEvent[];
    context: DigestStory[];
}

type Props$6 = {
    candles: Candle[];
    theme: ChartTheme;
    height?: number;
    onHoverChange?: (candle: Candle | null) => void;
};
declare const AreaChart: React.FC<Props$6>;

type Props$5 = {
    styles: WidgetStyle;
    dev?: boolean;
    assets?: StockAsset[];
    height?: number;
    fullWidth?: boolean;
    onAssetChange?: (symbol: string) => void;
};
declare const StockWidget: React.FC<Props$5>;

type Mover = {
    ticker: string;
    name: string;
    price: number;
    changeAbs: number;
    changePct: number;
    logo: string | null;
};
declare const MOVERS_LISTS: readonly ["active", "gainers", "losers"];
type MoversList = (typeof MOVERS_LISTS)[number];
type MoversTheme = {
    background: string;
    text: string;
    strong: string;
    up: string;
    down: string;
    divider: string;
};

type Props$4 = {
    styles: WidgetStyle;
    dev?: boolean;
    title?: string;
    visibleRows?: number;
    onMoverClick?: (mover: Mover) => void;
    fullWidth?: boolean;
};
declare const TopMovers: React.FC<Props$4>;

type AnalystRecommendationsMode = "vertical" | "horizontal";
type RawAnalystRecommendationsProps = {
    styles: WidgetStyle;
    assetId: number;
    showAsset: boolean;
    mode?: AnalystRecommendationsMode;
};
type AnalystRecommendationsProps = Omit<RawAnalystRecommendationsProps, "showAsset"> & {
    showAsset?: boolean;
    size?: "full" | "screen";
};
declare function RawAnalystRecommendations({ styles, assetId, showAsset, mode: modeProp, }: RawAnalystRecommendationsProps): React$1.JSX.Element;
declare function AnalystRecommendations({ styles, assetId, showAsset, mode, size, }: AnalystRecommendationsProps): React$1.JSX.Element;

type AnalystConsensusLabel = "strong_buy" | "moderate_buy" | "hold" | "moderate_sell" | "strong_sell" | "unknown";
type AnalystRecommendationCounts = {
    strongBuy: number;
    buy: number;
    hold: number;
    sell: number;
    strongSell: number;
    groupedBuy: number;
    groupedSell: number;
    total: number;
};
type AnalystRecommendationData = {
    asset: {
        id: number;
        symbol: string;
        name: string;
    };
    fetchedAt: string;
    recommendationScore: number | null;
    consensusLabel: AnalystConsensusLabel;
    counts: AnalystRecommendationCounts;
    targetMeanPrice: number | null;
    currency: string | null;
};
type AnalystRecommendationTheme = {
    text: string;
    secondaryText: string;
    padding: string;
    /** Backward-compatible aliases for consumers built against the first theme shape. */
    buy: string;
    neutral: string;
    sell: string;
    options: Record<Exclude<AnalystConsensusLabel, "unknown">, {
        bar: string;
        text: string;
    }>;
    track: string;
    needle: string;
};

type WidgetComboStyle = {
    wrapper: {
        fontFamily?: string;
        fontSize?: string;
        backgroundColor?: string;
        borderRadius?: string;
        borderWidth?: string;
        borderStyle?: string;
        borderColor?: string;
        boxShadow?: string;
        color?: string;
    };
    cta: {
        borderRadius: string;
        fontSize: string;
        borderWidth: string;
        borderStyle: string;
        borderColor: string;
        background: string;
        color: string;
        boxShadow: string;
        position: CtaPosition;
        label: string;
        link: string;
    };
    video: {
        borderRadius?: string;
    };
    signals: SignalsStyles;
    news: {
        imageBorderRadius: string;
        scrollMode: "virtual" | "pagination";
    };
};
type WidgetComboAssets = {
    forex: number[];
    stock: number[];
};
type WidgetComboType = "signals-news-dyntube";
interface WidgetComboStyleMetadata {
    id: string;
    brand_id: number;
    brand_name: string;
    lang_code: string;
    combo_type: WidgetComboType;
    name: string;
    is_active: boolean;
    status: 'draft' | 'published' | 'archived';
    schema_version: number;
    created_at?: string;
    updated_at?: string;
}
interface WidgetComboPayload {
    style: WidgetComboStyle;
    assets: WidgetComboAssets;
}
interface WidgetCombo extends WidgetComboStyleMetadata {
    payload: WidgetComboPayload;
}

interface Props$3 {
    widget: WidgetCombo;
    size?: "full" | "screen";
}
declare const SignalsNewsDyntube: FC<Props$3>;

interface Props$2 {
    styles: WidgetStyle;
    assetId: number;
    size?: "full" | "screen";
}
/** Auto-detecting overview — picks the right variant from the asset's class. */
declare function AssetOverview(props: Props$2): JSX.Element;
/** Equity overview (analyst consensus + volume, company logo). */
declare function StockOverview(props: Props$2): JSX.Element;
/** Forex-pair overview (no analyst, no volume, dual-currency badge). */
declare function ForexOverview(props: Props$2): JSX.Element;
/** Crypto overview (no analyst, volume kept, coin logo). */
declare function CryptoOverview(props: Props$2): JSX.Element;

interface Props$1 {
    styles: WidgetStyle;
    assets: StockAsset[];
    height?: number;
    dev?: boolean;
    fullWidth?: boolean;
}
declare function AssetPreviewContent({ styles, assets, height, dev, fullWidth, }: Props$1): JSX.Element | null;

interface Props {
    styles: WidgetStyle;
    assets: StockAsset[];
    size?: "full" | "screen";
    dev?: boolean;
}
declare function AssetPreview({ styles, assets, size, dev }: Props): JSX.Element;

type Currency = {
    id: number;
    name: string | null;
    symbol: string;
    major: boolean;
};

type Asset = {
    id: number;
    mark: string;
    company_name: string;
    symbol: string;
    lower_line: string;
    indicator_line: string;
    narration: string;
    chart_name: string;
    R1: string;
    R2: string;
    S1: string;
    S2: string;
    updated: Date;
};

type GlossaryDefinition = {
    id: number;
    title: string;
    definition: string;
    lang: string;
};

type NewsArticle = {
    itemCategory: string;
    headline: string;
    subheadline: string;
    content: string;
    articleBody?: string | null;
    articleBodyMd?: string | null;
    /** Short bullet list distilled from the article — rendered at the top of the article view. */
    keyTakeaways?: string[] | null;
    lang: string;
    dateCode: string;
    imageUrl: string;
    tag: string;
    source: string;
    isBreaking?: boolean;
    isLive?: boolean;
    breakingExpiresAt?: string | null;
    /** Editor-picked chart asset. Empty falls back to the category default. */
    assets?: StockAsset[];
};

type ThemeImage = {
    id?: number;
    name: string;
    category_key: string;
    category_label: string;
};

declare namespace EcoCal {
    export type EconomicEvent = {
        id: number;
        event_datetime: Date;
        iso_country_code: string;
        country: string;
        report_name: string;
        report_date: string;
        actual: string | null;
        previous: string | null;
        consensus: string | null;
        unit: string | null;
        impact_level: 1 | 2 | 3;
        impact_description: 'HIGH' | 'MEDIUM' | 'LOW';
        api_source: string;
        data_hash: string;
        created_at: Date;
        updated_at: Date;
        is_active: boolean;
    };
    type BaseTranslation = {
        name_id: number;
        category_name: string | null;
        name_type: string | null;
        _name: string | null;
    };
    type EconomicEventTranslation = {
        index_id: number;
        base_translation_id: number | null;
        translated_name: string | null;
        definition: string | null;
        short_definition: string | null;
    };
    export type EconomicEventWithTranslation = EconomicEvent & BaseTranslation & EconomicEventTranslation;
    export type DateFilterKey = "yesterday" | "today" | "tomorrow" | "week" | "lastWeek" | "nextWeek";
    export type ProcessedEvent = EconomicEventWithTranslation & {
        isLastPastEvent: boolean;
        isClosestEvent: boolean;
    };
    export type EventsByDate = Record<string, ProcessedEvent[]>;
    export type DateRange = {
        start: Date;
        end: Date;
    };
    export type StringDateRange = {
        start: string;
        end: string;
    };
    export {  };
}
declare namespace HolaPrimeEcoCal {
    export type EconomicEvent = EcoCal.EconomicEventWithTranslation & {
        impacted_forex_instruments: string[];
        impacted_future_instruments: string[];
    };
    type BaseTranslation = {
        name_id: number;
        category_name: string | null;
        name_type: string | null;
        _name: string | null;
    };
    type EconomicEventTranslation = {
        index_id: number;
        base_translation_id: number | null;
        translated_name: string | null;
        definition: string | null;
        short_definition: string | null;
    };
    export type EconomicEventWithTranslation = EconomicEvent & BaseTranslation & EconomicEventTranslation;
    export type DateFilterKey = "yesterday" | "today" | "tomorrow" | "week" | "lastWeek";
    export type ProcessedEvent = EconomicEventWithTranslation & {
        isLastPastEvent: boolean;
        isClosestEvent: boolean;
    };
    export type EventsByDate = Record<string, ProcessedEvent[]>;
    export type DateRange = {
        start: Date;
        end: Date;
    };
    export type StringDateRange = {
        start: string;
        end: string;
    };
    export {  };
}
declare namespace StockEcoCal {
    type EventType = "earnings" | "dividends" | "splits";
    type Event = {
        id: number;
        type: EventType;
        event_date: string;
        symbol: string;
        asset_name: string;
        impact: "LOW" | "MEDIUM" | "HIGH" | null;
        impacted_instruments: string[];
        eps_actual?: number | null;
        eps_estimated?: number | null;
        revenue_actual?: number | null;
        revenue_estimated?: number | null;
        ex_dividend_date?: string | null;
        payment_date?: string | null;
        dividend?: number | null;
        adjusted_dividend?: number | null;
        dividend_yield?: number | null;
        frequency?: string | null;
        split_ratio?: string | null;
        split_from?: number | null;
        split_to?: number | null;
    };
}

declare const FancyLoader: React__default.FC;

declare function getDictionarySection<K extends keyof Dictionary>(lang: string | null | undefined, section: K): Dictionary[K];

export { type AcademyChapter, AcademyChapters, type AcademyEpisode, type AcademyStyleMetadata, type AcademyWidget, type AcademyWidgetStyle, type AccountType, type AnalystConsensusLabel, type AnalystRecommendationCounts, type AnalystRecommendationData, type AnalystRecommendationTheme, AnalystRecommendations, type AnalystRecommendationsMode, type AnalystRecommendationsProps, AreaChart, type Asset, AssetOverview, AssetPreview, AssetPreviewContent, Branded, type Candle, type ChartTheme, type ChartType, CryptoOverview, CtaPosition, type Currency, CurrencyConverter, type Digest, type DigestEvent, type DigestLevels, type DigestNumber, type DigestSegment, type DigestStory, type DigestTerm, EcoCal, EconomicCalendar, FancyLoader, Fibonacci, ForexOverview, Glossary, type GlossaryDefinition, Heatmap, HolaPrimeEcoCal, HolaPrimeEconomicCalendar, HolaPrimeEconomicCalendarWithStocks, LiveUpdates, MOVERS_LISTS, MarginCalculator, type Mover, type MoversList, type MoversTheme, News, News2, News3, News4, type NewsArticle, Pivots, Positions, RawAnalystRecommendations, type RawAnalystRecommendationsProps, Signals, SignalsNewsDyntube, type StockAsset, StockEcoCal, StockOverview, type StockTimeframe, StockWidget, StopLossTakeProfit, StopLossTakeProfitLevels, type ThemeImage, TopMovers, VideoExplainer, VideoNews, type WidgetCombo, type WidgetComboAssets, type WidgetComboPayload, type WidgetComboStyle, type WidgetComboStyleMetadata, WidgetComboType$1 as WidgetComboType, WidgetStyle, getDictionarySection };