@exegia/corpora-ui 1.0.0 → 3.0.0

package/dist-lib/components/composed/ai/types.d.ts

@@ -0,0 +1,68 @@
+import { IChartProps, IComposerSuggestionsProps, IMarkdownProps, IResearchAnswerProps } from '../../../index';
+import { TUserType } from '../../atoms/types';
+import { ReactNode } from 'react';
+import { IRecommendationStackProps } from '../../blocks/types';
+export type TSuggestionState = "accepted" | "rejected" | "pending";
+export interface IDiffRow {
+    type: "add" | "remove";
+    value: ReactNode;
+    field?: string;
+}
+/** A word, or an inline citation; extra fields turn the chip into a hover preview. */
+export type TStreamingToken = {
+    text: string;
+} | {
+    cite: string;
+    favicon?: string;
+    title?: string;
+    description?: string;
+    href?: string;
+};
+export interface IStreamingTextProps extends React.ComponentPropsWithoutRef<"div"> {
+    /** Paragraphs, each a token list; a string is split on spaces. */
+    paragraphs: (string | TStreamingToken[])[];
+    /** Reveal words over time and show the caret. */
+    streaming?: boolean;
+    /** Reveal gap in ms; defaults to the --stream-gap token (60ms). */
+    wordMs?: number;
+}
+/** Kind → props map for message content; the source of truth for `AIContentProps`. */
+export interface IAIContentPropsMap {
+    markdown: IMarkdownProps;
+    research: IResearchAnswerProps;
+    chart: IChartProps;
+    suggestion: IComposerSuggestionsProps;
+    recommendation: IRecommendationStackProps;
+}
+export type TAIMessageType = keyof IAIContentPropsMap;
+/** Discriminated union of `{ kind } & props`, distributed over `T`. */
+export type TAIContentProps<T extends TAIMessageType = TAIMessageType> = {
+    [K in T]: {
+        kind: K;
+    } & IAIContentPropsMap[K];
+}[T];
+export interface IAIMessageProps<T extends TAIMessageType = TAIMessageType> {
+    /** Identity shown in the header. */
+    user?: TUserType;
+    type: T;
+    thinking?: boolean;
+    /** Replaces the default `User.Info` identity row in the header. */
+    AttachedContent?: React.ComponentType<TAIContentProps<T>>;
+    /** Props forwarded to `AttachedContent`, typed by `type`. */
+    contentProps?: IAIContentPropsMap[T];
+    children?: React.ReactNode;
+    isStreaming?: boolean;
+    className?: string;
+}
+export interface IReferenceBase {
+    id: string;
+    title?: string;
+    url?: string;
+}
+export interface IAISuggestionBase {
+    heading: string;
+    description?: string | React.ReactNode;
+    state?: TSuggestionState;
+    updatedAt?: string;
+    references?: IReferenceBase[] | IReferenceBase;
+}

package/dist-lib/components/composed/chat/attachment-file.d.ts

@@ -0,0 +1,17 @@
+export declare function attachmentMimeType(file: File): string;
+export declare function attachmentFileKind(file: File): {
+    kind: "image";
+} | {
+    kind: "media";
+    audio: boolean;
+} | {
+    kind: "document";
+};
+interface FilePreview {
+    file: File;
+    url?: string;
+    text?: string;
+}
+/** Each mounted attachment owns its URL, so clearing the tray cannot break a sent preview. */
+export declare function useAttachmentFile(file?: File): FilePreview | undefined;
+export {};

package/dist-lib/components/composed/chat/attachment.d.ts

@@ -0,0 +1,60 @@
+import { ReactElement, ReactNode } from 'react';
+export type TAttachmentKind = "document" | "image" | "media" | "text-selection" | "chat-reply" | "username-handle" | "url-link";
+export type TAttachmentVariant = "default" | "preview";
+interface IAttachmentBase {
+    id?: string;
+    className?: string;
+    style?: React.CSSProperties;
+    /** `default` is a compact chip with a hover preview; `preview` displays the content directly. */
+    variant?: TAttachmentVariant;
+    title: ReactNode;
+    meta?: ReactNode;
+    onRemove?: () => void;
+    removable?: boolean;
+    /** A local file, retained through sending. Its type and preview are resolved automatically. */
+    file?: File;
+    /** Content URL for an uploaded file, image, media or document. */
+    src?: string;
+    /** A supplied thumbnail takes precedence over a generated image/video frame. */
+    thumbnail?: string;
+    /** Custom rich hover content, for formats the browser cannot display itself. */
+    preview?: ReactNode;
+    /** A document excerpt; text files generate one automatically (first 8 KB). */
+    previewText?: string;
+    mimeType?: string;
+}
+export type TAttachmentProps = IAttachmentBase & ({
+    kind: "document";
+    onAction?: () => void;
+    actionIcon?: ReactNode;
+} | {
+    kind: "image";
+    alt?: string;
+} | {
+    kind: "media";
+    poster?: string;
+    duration?: ReactNode;
+    audio?: boolean;
+    onPlay?: () => void;
+    waveform?: number[];
+} | {
+    kind: "text-selection";
+    quote?: ReactNode;
+} | {
+    kind: "chat-reply";
+    author?: ReactNode;
+    time?: ReactNode;
+    body?: ReactNode;
+} | {
+    kind: "username-handle";
+    initials?: string;
+} | {
+    kind: "url-link";
+    domain?: ReactNode;
+    description?: ReactNode;
+    favicon?: string;
+    href?: string;
+});
+/** Compact attachments open their content on hover/focus; expanded content has no nested preview. */
+export declare function Attachment(props: TAttachmentProps): ReactElement;
+export {};

package/dist-lib/components/composed/chat/chart/chart-atom.d.ts

@@ -0,0 +1,30 @@
+import { IChartState, TChartInstanceId } from './type';
+export declare const chartSelectedKeyAtom: (id: TChartInstanceId) => import('jotai').PrimitiveAtom<string | null> & {
+    init: string | null;
+};
+export declare const chartStateAtom: (id: TChartInstanceId) => import('jotai').Atom<IChartState>;
+export declare const selectChartKeyAtom: (id: TChartInstanceId) => import('jotai').WritableAtom<null, [key: string | null], void> & {
+    init: null;
+};
+export declare const toggleChartKeyAtom: (id: TChartInstanceId) => import('jotai').WritableAtom<null, [key: string], void> & {
+    init: null;
+};
+export declare const resetChartAtom: (id: TChartInstanceId) => import('jotai').WritableAtom<null, [], void> & {
+    init: null;
+};
+/** @internal Mounted root projects configuration and controlled props. */
+export declare const chartConfigAtom: (id: TChartInstanceId) => import('jotai').PrimitiveAtom<{
+    controlled: boolean;
+    initial: string | null;
+    keys: readonly string[];
+    onChange?: (key: string | null) => void;
+}> & {
+    init: {
+        controlled: boolean;
+        initial: string | null;
+        keys: readonly string[];
+        onChange?: (key: string | null) => void;
+    };
+};
+/** Call only after all consumers of a named instance have unmounted. */
+export declare function removeChartInstance(id: TChartInstanceId): void;

package/dist-lib/components/composed/chat/chart/chart-context.d.ts

@@ -0,0 +1,2 @@
+export declare const ChartContext: import('react').Context<string | null>;
+export declare function useChartContext(): string;

package/dist-lib/components/composed/chat/chart/chart-legend.d.ts

@@ -0,0 +1,4 @@
+import { IChartProps } from './type';
+export declare function ChartLegend({ type, data, series, selectedKey, interactive, onSelect, }: Pick<IChartProps, "type" | "data" | "series" | "selectedKey" | "interactive"> & {
+    onSelect: (key: string) => void;
+}): import("react").JSX.Element;

package/dist-lib/components/composed/chat/chart/chart-plot.d.ts

@@ -0,0 +1,3 @@
+import { IChartProps } from './type';
+/** Wait for layout before initializing ECharts (also supports hidden tabs and SSR). */
+export declare function ChartPlot(props: IChartProps): import("react").JSX.Element;

package/dist-lib/components/composed/chat/chart/chart-root.d.ts

@@ -0,0 +1,3 @@
+import { IChartProps } from './type';
+import type * as React from "react";
+export declare function ChartRoot({ ref, ...allProps }: IChartProps): React.ReactElement;

package/dist-lib/components/composed/chat/chart/chart-tooltip.d.ts

@@ -0,0 +1,4 @@
+import { TooltipProps } from './evilcharts/echarts-area-chart';
+import { IChartSeries, TChartDatum, TChartType } from './type';
+/** React escapes labels and formatted nodes before they enter ECharts' HTML tooltip. */
+export declare function createChartTooltip(type: TChartType, data: TChartDatum[], series: IChartSeries[], options?: TooltipProps): (params: unknown) => string;

package/dist-lib/components/composed/chat/chart/constants.d.ts

@@ -0,0 +1,3 @@
+import { TChartType } from './type';
+export declare const CHART_TYPE_LABEL: Record<TChartType, string>;
+export declare const CHART_DEFAULT_HEIGHT = 150;

package/dist-lib/components/composed/chat/chart/evilcharts/echarts-area-chart.d.ts

@@ -0,0 +1,93 @@
+import { ChartConfig, EChartsRenderer } from './echarts-chart';
+import { TooltipPosition, TooltipRoundness, TooltipVariant } from './echarts-tooltip';
+import { BrushProps } from './echarts-brush';
+import { FC, ReactNode } from 'react';
+import { DotVariant } from './echarts-dot';
+import { LegendVariant } from './echarts-legend';
+export type { ChartConfig, DotVariant, EChartsRenderer, LegendVariant, TooltipPosition, TooltipRoundness, TooltipVariant, };
+export type AreaVariant = "gradient" | "gradient-reverse" | "solid" | "dotted" | "lines" | "hatched" | "none";
+export type StrokeVariant = "solid" | "dashed" | "animated-dashed";
+export type StackType = "default" | "stacked" | "expanded";
+export type AreaAnimationType = "none" | "left-to-right" | "right-to-left" | "center-out" | "edges-in";
+export type CurveType = "linear" | "smooth" | "bump" | "monotone" | "monotoneX" | "monotoneY" | "natural" | "step";
+export interface EChartsAreaChartProps<TData extends Record<string, unknown>> {
+    data: TData[];
+    config: ChartConfig;
+    renderer?: EChartsRenderer;
+    xDataKey?: keyof TData & string;
+    className?: string;
+    curveType?: CurveType;
+    stackType?: StackType;
+    animation?: boolean;
+    animationType?: AreaAnimationType;
+    enableHoverHighlight?: boolean;
+    enableHoverReveal?: boolean;
+    defaultSelectedDataKey?: string | null;
+    selectedDataKey?: string | null;
+    onSelectionChange?: (key: string | null) => void;
+    isLoading?: boolean;
+    loadingPoints?: number;
+    chartOptions?: Record<string, unknown>;
+    children?: ReactNode;
+}
+export interface AreaProps {
+    dataKey: string;
+    variant?: AreaVariant;
+    strokeVariant?: StrokeVariant;
+    strokeWidth?: number;
+    curveType?: CurveType;
+    animationType?: AreaAnimationType;
+    connectNulls?: boolean;
+    isClickable?: boolean;
+    enableBufferLine?: boolean;
+    children?: ReactNode;
+}
+export interface DotProps {
+    variant?: DotVariant;
+}
+export interface XAxisProps {
+    dataKey?: string;
+    tickFormatter?: (value: string, index: number) => string;
+    label?: string;
+    hideDots?: boolean;
+}
+export interface YAxisProps {
+    dataKey?: string;
+    tickFormatter?: (value: number, index: number) => string;
+    label?: string;
+    hideDots?: boolean;
+}
+export interface TooltipProps {
+    variant?: TooltipVariant;
+    roundness?: TooltipRoundness;
+    cursor?: boolean;
+    position?: TooltipPosition;
+}
+export interface LegendProps {
+    variant?: LegendVariant;
+    align?: "left" | "center" | "right";
+    verticalAlign?: "top" | "middle" | "bottom";
+    isClickable?: boolean;
+}
+/**
+ * Apache ECharts port of the EvilCharts area chart, exposing a compound-as-config
+ * API so its JSX reads identically to the Recharts twin. The root owns the data,
+ * config, selection state, loading skeleton, intro reveal, and optional zoom
+ * brush; every visual part — `<Area>`, `<XAxis>`, `<YAxis>`, `<Grid>`,
+ * `<Tooltip>`, `<Legend>` — is composed as a declarative child that renders
+ * nothing. The root walks those children by reference and drives a single
+ * imperative ECharts instance. Fully self-contained: its only dependencies are
+ * `react` and `echarts`.
+ */
+export declare function EChartsAreaChart<TData extends Record<string, unknown>>({ data, config, renderer, xDataKey, className, curveType, stackType, animation, animationType, enableHoverHighlight, enableHoverReveal, defaultSelectedDataKey, selectedDataKey: selectedDataKeyProp, onSelectionChange, isLoading, loadingPoints, chartOptions, children, }: EChartsAreaChartProps<TData>): import("react").JSX.Element;
+export declare namespace EChartsAreaChart {
+    var Area: FC<AreaProps>;
+    var Dot: FC<DotProps>;
+    var ActiveDot: FC<DotProps>;
+    var XAxis: FC<XAxisProps>;
+    var YAxis: FC<YAxisProps>;
+    var Grid: FC;
+    var Tooltip: FC<TooltipProps>;
+    var Legend: FC<LegendProps>;
+    var Brush: FC<BrushProps>;
+}

package/dist-lib/components/composed/chat/chart/evilcharts/echarts-bar-chart.d.ts

@@ -0,0 +1,86 @@
+import { ChartConfig, EChartsRenderer } from './echarts-chart';
+import { TooltipPosition, TooltipRoundness, TooltipVariant } from './echarts-tooltip';
+import { BrushProps } from './echarts-brush';
+import { FC, ReactNode } from 'react';
+import { LegendVariant } from './echarts-legend';
+export type { ChartConfig, EChartsRenderer, LegendVariant, TooltipPosition, TooltipRoundness, TooltipVariant, };
+export type BarVariant = "default" | "hatched" | "duotone" | "duotone-reverse" | "gradient" | "stripped" | "blocks" | "expandable";
+export type StackType = "default" | "stacked" | "percent";
+export type BarLayout = "vertical" | "horizontal";
+export type BarAnimationType = "none" | "left-to-right" | "right-to-left" | "center-out" | "edges-in";
+export interface EChartsBarChartProps<TData extends Record<string, unknown>> {
+    data: TData[];
+    config: ChartConfig;
+    renderer?: EChartsRenderer;
+    xDataKey?: keyof TData & string;
+    className?: string;
+    stackType?: StackType;
+    layout?: BarLayout;
+    barRadius?: number;
+    animation?: boolean;
+    animationType?: BarAnimationType;
+    barGap?: number;
+    barCategoryGap?: number;
+    selectedDataKey?: string | null;
+    defaultSelectedDataKey?: string | null;
+    onSelectionChange?: (key: string | null) => void;
+    enableMaxValueHighlight?: boolean;
+    isLoading?: boolean;
+    loadingBars?: number;
+    chartOptions?: Record<string, unknown>;
+    children?: ReactNode;
+}
+export interface BarProps {
+    dataKey: string;
+    variant?: BarVariant;
+    radius?: number;
+    animationType?: BarAnimationType;
+    isClickable?: boolean;
+    enableHoverHighlight?: boolean;
+    glowing?: boolean;
+    bufferBar?: boolean;
+}
+export interface XAxisProps {
+    dataKey?: string;
+    tickFormatter?: (value: string, index: number) => string;
+    label?: string;
+    hideDots?: boolean;
+}
+export interface YAxisProps {
+    dataKey?: string;
+    tickFormatter?: (value: string, index: number) => string;
+    label?: string;
+    hideDots?: boolean;
+}
+export interface TooltipProps {
+    variant?: TooltipVariant;
+    roundness?: TooltipRoundness;
+    defaultIndex?: number;
+    position?: TooltipPosition;
+}
+export interface LegendProps {
+    variant?: LegendVariant;
+    align?: "left" | "center" | "right";
+    verticalAlign?: "top" | "middle" | "bottom";
+    isClickable?: boolean;
+}
+/**
+ * Apache ECharts port of the EvilCharts bar chart, exposing a compound-as-config
+ * API so its JSX reads identically to the Recharts twin. The root owns the data,
+ * config, selection state, loading skeleton, intro grow-in, and optional zoom
+ * brush; every visual part — `<Bar>`, `<XAxis>`, `<YAxis>`, `<Grid>`,
+ * `<Tooltip>`, `<Legend>` — is composed as a declarative child that renders
+ * nothing. The root walks those children by reference and drives a single
+ * imperative ECharts instance. Fully self-contained: its only dependencies are
+ * `react`, `echarts`, and `motion`.
+ */
+export declare function EChartsBarChart<TData extends Record<string, unknown>>({ data, config, renderer, xDataKey, className, stackType, layout, barRadius, animation, animationType, barGap, barCategoryGap, selectedDataKey: selectedDataKeyProp, defaultSelectedDataKey, onSelectionChange, enableMaxValueHighlight, isLoading, loadingBars, chartOptions, children, }: EChartsBarChartProps<TData>): import("react").JSX.Element;
+export declare namespace EChartsBarChart {
+    var Bar: FC<BarProps>;
+    var XAxis: FC<XAxisProps>;
+    var YAxis: FC<YAxisProps>;
+    var Grid: FC;
+    var Tooltip: FC<TooltipProps>;
+    var Legend: FC<LegendProps>;
+    var Brush: FC<BrushProps>;
+}

package/dist-lib/components/composed/chat/chart/evilcharts/echarts-brush.d.ts

@@ -0,0 +1,65 @@
+import { ResolvedColors } from './echarts-chart';
+import { DataZoomComponentOption } from 'echarts/components';
+import { FC } from 'react';
+import * as echarts from "echarts/core";
+type EChartsInstance = ReturnType<typeof echarts.init>;
+declare const BRUSH_BORDER_OPACITY = 1;
+export { BRUSH_BORDER_OPACITY };
+export interface BrushProps {
+    height?: number;
+    formatLabel?: (value: string, index: number) => string;
+    onChange?: (range: {
+        startIndex: number;
+        endIndex: number;
+    }) => void;
+}
+/** Declares the zoom brush below the chart. Presence renders it; renders nothing itself. */
+export declare const Brush: FC<BrushProps>;
+export type BrushRange = {
+    start: number;
+    end: number;
+};
+export type BrushGeometry = {
+    bottom: number;
+    height: number;
+};
+export type BrushOverlayParams = {
+    range: BrushRange;
+    geom: BrushGeometry;
+    size: {
+        width: number;
+        height: number;
+    };
+    tokens: ResolvedColors["tokens"];
+    labels: {
+        start: string;
+        end: string;
+    } | null;
+    showLabels: boolean;
+    hover: {
+        left: boolean;
+        right: boolean;
+    };
+};
+type ZrRect = InstanceType<typeof echarts.graphic.Rect>;
+type ZrCircle = InstanceType<typeof echarts.graphic.Circle>;
+type ZrText = InstanceType<typeof echarts.graphic.Text>;
+export type BrushOverlayElements = {
+    dimLeft: ZrRect;
+    dimRight: ZrRect;
+    frame: ZrRect;
+    pillLeft: ZrRect;
+    pillRight: ZrRect;
+    grips: ZrCircle[];
+    labelStart: ZrText;
+    labelEnd: ZrText;
+};
+export declare function syncBrushOverlay(chart: EChartsInstance, store: {
+    brushOverlay: BrushOverlayElements | null;
+}, params: BrushOverlayParams | null): void;
+export declare function buildBrushDataZoom(params: {
+    brushBottom: number;
+    brushHeight: number;
+    brushRange: BrushRange;
+    fillerColor: string;
+}): DataZoomComponentOption[];

package/dist-lib/components/composed/chat/chart/evilcharts/echarts-chart.d.ts

@@ -0,0 +1,44 @@
+import { ComponentType, ReactNode } from 'react';
+import * as echarts from "echarts/core";
+export declare const ECHARTS_RENDERERS: {
+    readonly canvas: "canvas";
+    readonly svg: "svg";
+};
+export type EChartsRenderer = (typeof ECHARTS_RENDERERS)[keyof typeof ECHARTS_RENDERERS];
+export declare const DEFAULT_ECHARTS_RENDERER: "canvas";
+export declare const THEMES: {
+    readonly light: "";
+    readonly dark: ".dark";
+};
+export type ThemeKey = keyof typeof THEMES;
+export declare const THEME_KEYS: ThemeKey[];
+export type AtLeastOneThemeColor = {
+    light: string[];
+    dark?: string[];
+} | {
+    light?: string[];
+    dark: string[];
+};
+export type ChartConfig = Record<string, {
+    label?: ReactNode;
+    icon?: ComponentType;
+    colors?: AtLeastOneThemeColor;
+}>;
+export declare function getColorsCount(item: ChartConfig[string]): number;
+export declare function distributeColors(colors: string[], maxCount: number): string[];
+export declare function buildChartCss(id: string, config: ChartConfig): string;
+export declare function normalizeColor(value: string): string;
+export declare function withAlpha(color: string, alpha: number): string;
+export type ResolvedColors = {
+    series: Record<string, string[]>;
+    tokens: {
+        mutedForeground: string;
+        border: string;
+        foreground: string;
+        background: string;
+    };
+};
+export declare function resolveColors(container: HTMLElement, config: ChartConfig, seriesKeys: string[]): ResolvedColors;
+export declare function seriesPaint(slots: string[]): string | echarts.graphic.LinearGradient;
+export declare function indicatorBackground(key: string, colorsCount: number): string;
+export declare function flattenColor(color: string, base: string): string;

package/dist-lib/components/composed/chat/chart/evilcharts/echarts-dot.d.ts

@@ -0,0 +1,16 @@
+import type * as echarts from "echarts/core";
+export type DotVariant = "none" | "default" | "border" | "colored-border" | "ping";
+export type DotItemStyleOption = {
+    color?: string | echarts.graphic.LinearGradient;
+    borderColor?: string | echarts.graphic.LinearGradient;
+    borderWidth?: number;
+    opacity?: number;
+};
+export type DotStyle = {
+    size: number;
+    itemStyle: DotItemStyleOption;
+};
+export declare function dotItemStyle(variant: DotVariant, paint: string | echarts.graphic.LinearGradient, background: string): DotItemStyleOption;
+export declare const DOT_SIZES: Record<DotVariant, number>;
+export declare function dotStyle(variant: DotVariant, paint: string | echarts.graphic.LinearGradient, background: string): DotStyle;
+export declare function sampleGradient(slots: string[], t: number): string;

package/dist-lib/components/composed/chat/chart/evilcharts/echarts-legend.d.ts

@@ -0,0 +1,24 @@
+import { ChartConfig } from './echarts-chart';
+import { CSSProperties } from 'react';
+export type LegendVariant = "square" | "circle" | "circle-outline" | "rounded-square" | "rounded-square-outline" | "vertical-bar" | "horizontal-bar";
+export declare function legendFillStyle(key: string, colorsCount: number): CSSProperties;
+export declare function legendOutlineStyle(key: string, colorsCount: number): CSSProperties;
+export declare function LegendIndicator({ variant, dataKey, colorsCount, }: {
+    variant: LegendVariant;
+    dataKey: string;
+    colorsCount: number;
+}): import("react").JSX.Element;
+type LegendOverlayProps = {
+    seriesKeys: string[];
+    config: ChartConfig;
+    variant: LegendVariant;
+    align: "left" | "center" | "right";
+    verticalAlign: "top" | "middle" | "bottom";
+    selectedKey: string | null;
+    hoveredKey: string | null;
+    isClickable: boolean;
+    onToggle: (key: string) => void;
+    style: CSSProperties;
+};
+export declare function LegendOverlay({ seriesKeys, config, variant, align, selectedKey, hoveredKey, isClickable, onToggle, style, }: LegendOverlayProps): import("react").JSX.Element;
+export {};

package/dist-lib/components/composed/chat/chart/evilcharts/echarts-line-chart.d.ts

@@ -0,0 +1,90 @@
+import { ChartConfig, EChartsRenderer } from './echarts-chart';
+import { TooltipPosition, TooltipRoundness, TooltipVariant } from './echarts-tooltip';
+import { BrushProps } from './echarts-brush';
+import { FC, ReactNode } from 'react';
+import { DotVariant } from './echarts-dot';
+import { LegendVariant } from './echarts-legend';
+export type { ChartConfig, DotVariant, EChartsRenderer, LegendVariant, TooltipPosition, TooltipRoundness, TooltipVariant, };
+export type StrokeVariant = "solid" | "dashed" | "animated-dashed";
+export type LineAnimationType = "none" | "left-to-right" | "right-to-left" | "center-out" | "edges-in";
+export type CurveType = "linear" | "smooth" | "bump" | "monotone" | "monotoneX" | "monotoneY" | "natural" | "step";
+export interface EChartsLineChartProps<TData extends Record<string, unknown>> {
+    data: TData[];
+    config: ChartConfig;
+    renderer?: EChartsRenderer;
+    xDataKey?: keyof TData & string;
+    className?: string;
+    curveType?: CurveType;
+    animation?: boolean;
+    animationType?: LineAnimationType;
+    enableHoverHighlight?: boolean;
+    enableHoverReveal?: boolean;
+    selectedDataKey?: string | null;
+    defaultSelectedDataKey?: string | null;
+    onSelectionChange?: (key: string | null) => void;
+    isLoading?: boolean;
+    loadingPoints?: number;
+    chartOptions?: Record<string, unknown>;
+    children?: ReactNode;
+}
+export interface LineProps {
+    dataKey: string;
+    strokeVariant?: StrokeVariant;
+    strokeWidth?: number;
+    curveType?: CurveType;
+    animationType?: LineAnimationType;
+    connectNulls?: boolean;
+    isClickable?: boolean;
+    glowing?: boolean;
+    enableBufferLine?: boolean;
+    children?: ReactNode;
+}
+export interface DotProps {
+    variant?: DotVariant;
+}
+export interface XAxisProps {
+    dataKey?: string;
+    tickFormatter?: (value: string, index: number) => string;
+    label?: string;
+    hideDots?: boolean;
+}
+export interface YAxisProps {
+    dataKey?: string;
+    tickFormatter?: (value: number, index: number) => string;
+    label?: string;
+    hideDots?: boolean;
+}
+export interface TooltipProps {
+    variant?: TooltipVariant;
+    roundness?: TooltipRoundness;
+    cursor?: boolean;
+    position?: TooltipPosition;
+}
+export interface LegendProps {
+    variant?: LegendVariant;
+    align?: "left" | "center" | "right";
+    verticalAlign?: "top" | "middle" | "bottom";
+    isClickable?: boolean;
+}
+/**
+ * Apache ECharts port of the EvilCharts line chart, exposing a compound-as-config
+ * API so its JSX reads identically to the Recharts twin. The root owns the data,
+ * config, selection state, loading skeleton, intro reveal, and optional zoom
+ * brush; every visual part — `<Line>`, `<XAxis>`, `<YAxis>`, `<Grid>`,
+ * `<Tooltip>`, `<Legend>` — is composed as a declarative child that renders
+ * nothing. The root walks those children by reference and drives a single
+ * imperative ECharts instance. Fully self-contained: its only dependencies are
+ * `react`, `echarts`, and `motion`.
+ */
+export declare function EChartsLineChart<TData extends Record<string, unknown>>({ data, config, renderer, xDataKey, className, curveType, animation, animationType, enableHoverHighlight, enableHoverReveal, selectedDataKey: selectedDataKeyProp, defaultSelectedDataKey, onSelectionChange, isLoading, loadingPoints, chartOptions, children, }: EChartsLineChartProps<TData>): import("react").JSX.Element;
+export declare namespace EChartsLineChart {
+    var Line: FC<LineProps>;
+    var Dot: FC<DotProps>;
+    var ActiveDot: FC<DotProps>;
+    var XAxis: FC<XAxisProps>;
+    var YAxis: FC<YAxisProps>;
+    var Grid: FC;
+    var Tooltip: FC<TooltipProps>;
+    var Legend: FC<LegendProps>;
+    var Brush: FC<BrushProps>;
+}