@acronis-platform/ui-react 0.60.0 → 0.61.0

package/dist/src/components/ui/radial-bar-chart/radial-bar-chart.d.ts

@@ -1,22 +1,148 @@
-import { ChartTooltip, ChartConfig } from '../chart';
+import { ChartTooltip, ChartConfig, ChartAnimationProps, ChartDataLabelProps, PolarLabelPosition, TickFormatter } from '../chart';
 import * as React from 'react';
-export interface RadialBarChartProps extends Omit<React.ComponentProps<'div'>, 'children'> {
+/** Row-per-arc datum: the `nameKey` label plus each metric's numeric value. */
+type RadialBarChartDatum = Record<string, string | number>;
+/** What an arc's data label reads. */
+export type RadialBarChartLabelFormat = 'value' | 'name-value';
+export interface RadialBarChartCenterLabel {
+    /** Headline metric rendered large in the hole (e.g. the gauge's value). */
+    value?: string | number;
+    /** Caption rendered under the value. */
+    label?: string | number;
+}
+/**
+ * Compose one arc's data-label text. Exported for unit tests; not part of the
+ * package's public API.
+ *
+ * `labelFormatter` only ever formats the numeric part, so a chart's labels and
+ * its tooltip stay in the same units under either format. A nullish value yields
+ * an empty label, which recharts renders as no `<text>` at all.
+ */
+export declare function radialBarChartLabelText(options: {
+    format: RadialBarChartLabelFormat;
+    name: string | number | undefined;
+    value: string | number | undefined;
+    formatter?: TickFormatter;
+}): string;
+/** One piece of a segmented gauge's ring: a length in degrees and what it is. */
+export interface RadialBarChartSegment {
+    /** Synthetic series key — stable for a given (index, kind). */
+    key: string;
+    /** Angular length of the piece, in degrees. */
+    degrees: number;
+    /** `value` is the metric, `track` the unreached remainder, `gap` the notch. */
+    kind: 'value' | 'track' | 'gap';
+}
+/**
+ * Cut a gauge's sweep into equal segments separated by gaps, and split the
+ * segment the value ends inside into its reached and unreached parts. Exported
+ * for unit tests; not part of the package's public API.
+ *
+ * Lengths come back in **degrees**, which is what lets the ring be built as one
+ * stack of synthetic series over a `[0, sweep]` angular scale: recharts lays
+ * stacked radial bars out sequentially along the angle, so a transparent series
+ * between two colored ones reads as a real notch in the ring. A `gap` that
+ * would leave no room for the segments themselves is clamped.
+ */
+export declare function radialBarChartSegments(options: {
+    value: number;
+    domain: [number, number];
+    segments: number;
+    gap: number;
+    /** Absolute sweep of the chart, in degrees. */
+    sweep: number;
+    /** A full-circle sweep also needs a gap between the last segment and the first. */
+    closed: boolean;
+}): RadialBarChartSegment[];
+/**
+ * Fill for one piece of a segmented gauge's ring. Exported for unit tests and so
+ * the forced-open tooltip story can build a ring from the real implementation
+ * rather than a copy of it; not part of the package's public API.
+ */
+export declare function radialBarChartSegmentFill(kind: RadialBarChartSegment['kind'], colorName: string | number): string;
+/**
+ * What a segmented gauge's tooltip reads. Exported for unit tests; not part of
+ * the package's public API.
+ *
+ * A segmented ring's series are pieces of geometry, so recharts would offer the
+ * hovered piece's own name and length ("seg-3-value", 41.2°). Hovering anywhere
+ * on the ring should read the metric instead, so the reading is rebuilt from the
+ * data row.
+ */
+export declare function radialBarChartSegmentedReading(options: {
+    config: ChartConfig;
+    row: RadialBarChartDatum;
+    nameKey: string;
+    dataKey: string;
+    /** The `valueDomain` maximum, when the gauge has one. */
+    domainMax?: number;
+}): {
+    colorName: string;
+    label: React.ReactNode;
+    valueText: string;
+};
+/**
+ * The tooltip a segmented gauge shows — the same swatch/name/value layout the
+ * default `ChartTooltipContent` row uses, dot included, over the reading from
+ * `radialBarChartSegmentedReading`. Exported for the forced-open
+ * visual-regression story; not part of the package's public API.
+ *
+ * `payload` is trimmed to one row: a radial tooltip is axis-shared and collects a
+ * row from every series — two dozen identical rows for one metric.
+ * (`tooltipType="none"` only tags them, and scoping the tooltip to the hovered
+ * item instead would drop it in the corner — unlike Pie/Bar sectors, a RadialBar
+ * sector carries no tooltip coordinate.)
+ *
+ * A real component rather than a closure so it can be handed to `ChartTooltip`
+ * as an *element*: recharts `cloneElement`s an element but `createElement`s a
+ * function, and a closure rebuilt each render is a new element *type* — which
+ * remounts the tooltip on every parent render instead of updating it.
+ */
+export declare function RadialBarChartSegmentedTooltipContent({ active, payload, ...reading }: {
+    active?: boolean;
+    payload?: readonly unknown[];
+    config: ChartConfig;
+    row: RadialBarChartDatum;
+    nameKey: string;
+    dataKey: string;
+    domainMax?: number;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * The band a multi-metric tooltip's header names. Exported for unit tests; not
+ * part of the package's public API.
+ *
+ * Each tooltip row is one metric, so the header names the band the hovered arc
+ * belongs to. recharts' own label is the radius-axis index, which reads as a
+ * bare number.
+ */
+export declare function radialBarChartBandName(row: RadialBarChartDatum | undefined, nameKey: string): string;
+export interface RadialBarChartProps extends Omit<React.ComponentProps<'div'>, 'children'>, ChartAnimationProps, ChartDataLabelProps {
     /** Row-per-arc data. Each object holds the arc's `nameKey` label + its `dataKey` numeric value. */
-    data: ReadonlyArray<Record<string, string | number>>;
+    data: ReadonlyArray<RadialBarChartDatum>;
     /**
-     * Per-arc map of `label` / `color`, keyed by the arc's `nameKey` value
-     * (imported from the shared `Chart` primitives). Turned into `--color-<name>`
-     * custom properties. Colors are caller-supplied — reference an existing
-     * semantic `--ui-*` token; there is no chart palette tier yet.
+     * Per-arc map of `label` / `color`, keyed by the arc's `nameKey` value — or, in
+     * multi-metric mode, by each `dataKeys` entry (imported from the shared `Chart`
+     * primitives). Turned into `--color-<name>` custom properties. Colors are
+     * caller-supplied — reference an existing semantic `--ui-*` token; there is no
+     * chart palette tier yet.
      */
     config: ChartConfig;
-    /** Numeric field that sizes each arc. */
+    /** Numeric field that sizes each arc. Ignored when `dataKeys` is set. */
     dataKey: string;
+    /**
+     * Plot several metrics instead of one arc per row: one arc per key, colored and
+     * named from `config` keyed by the **key** (not by `nameKey`) — the same
+     * convention as the cartesian charts. Every metric shares one angular scale, so
+     * pair it with `valueDomain` when the metrics are measured against a known
+     * maximum. `nameKey` still names the band each metric's arc sits in.
+     */
+    dataKeys?: string[];
     /**
      * Label field that names each arc (drives the legend, tooltip, and
      * `--color-<name>` lookup). Values should be unique per chart (arcs sharing a
      * name share one `config`/color entry) and CSS-safe — they become part of a
-     * custom-property name.
+     * custom-property name. In multi-metric mode it names the band rather than the
+     * arc, so the legend and colors come from `dataKeys` instead.
      */
     nameKey: string;
     /** Inner radius of the innermost arc. */
@@ -27,10 +153,74 @@ export interface RadialBarChartProps extends Omit<React.ComponentProps<'div'>, '
     startAngle?: number;
     /** Angle (degrees) the arcs sweep to (default is a full clockwise circle). */
     endAngle?: number;
+    /**
+     * The value range the sweep represents, as `[min, max]`. Without it every arc
+     * is drawn relative to the largest value in the data — so a **single** value
+     * always fills the whole sweep, which is never what a gauge means. Set it to
+     * the metric's own scale (e.g. `[0, 100]` for a percentage) and each arc
+     * becomes that fraction of the sweep, over the `showBackground` track.
+     */
+    valueDomain?: [number, number];
     /** Corner radius on each arc's ends. */
     cornerRadius?: number;
+    /**
+     * Horizontal center of the arcs, in px or a percentage of the width.
+     * Defaults to the middle (`50%`).
+     */
+    cx?: number | string;
+    /**
+     * Vertical center of the arcs, in px or a percentage of the height. Defaults to
+     * the middle (`50%`) — worth moving for a half-circle gauge, whose drawn half
+     * otherwise sits in the upper half of the surface.
+     */
+    cy?: number | string;
+    /** Thickness of each arc, in px. Omit to let the radii and the gaps size it. */
+    barSize?: number;
+    /** Gap between the arcs of different metrics in one band, in px. */
+    barGap?: number | string;
+    /** Gap between bands, in px or a percentage string. */
+    barCategoryGap?: number | string;
+    /**
+     * Smallest angle a non-zero arc may occupy, in degrees, so a tiny value stays
+     * visible (and hoverable). recharts applies the floor to a `0` as well, which
+     * reads as a small positive value — leave this unset when a metric can
+     * legitimately be zero.
+     */
+    minAngle?: number;
+    /** Plot-area margin, in px. Omit to use recharts' default (5 on every side). */
+    margin?: {
+        top?: number;
+        right?: number;
+        bottom?: number;
+        left?: number;
+    };
+    /**
+     * Draw the gauge's ring as this many equal segments, notched apart — the
+     * segmented-gauge look. Applies to a **single-value gauge** only and needs
+     * `valueDomain` to know what a full ring means. Anything that isn't one — more
+     * than one row, `dataKeys` set, fewer than two segments, or a `dataKey` value
+     * that isn't a number (a stringified `"29"` off an API) — falls back to the
+     * normal concentric arcs, legend included, rather than erroring.
+     *
+     * The ring is then synthetic geometry rather than data rows, so the arc labels
+     * and the legend are suppressed: put the readout in `centerLabel`. The tooltip
+     * stays, and reads the metric (with the `valueDomain` maximum when there is
+     * one) wherever on the ring it is hovered. `showBackground` is redundant too —
+     * the unreached segments *are* the track.
+     */
+    segments?: number;
+    /** Gap between a segmented gauge's segments, in degrees. Defaults to `3`. */
+    segmentGap?: number;
     /** Render a muted background track behind each arc. */
     showBackground?: boolean;
+    /** Draw the concentric polar grid behind the arcs. */
+    showPolarGrid?: boolean;
+    /**
+     * Custom content for the hole at the center — a headline `value` and/or a
+     * `label` caption, stacked and centered. Needs an `innerRadius` big enough to
+     * hold the text; it is not clipped to the hole.
+     */
+    centerLabel?: RadialBarChartCenterLabel;
     showTooltip?: boolean;
     showLegend?: boolean;
     /**
@@ -38,8 +228,24 @@ export interface RadialBarChartProps extends Omit<React.ComponentProps<'div'>, '
      * (imported from this library) — e.g. with a `formatter` / `labelFormatter` —
      * to customize formatting, per-arc rows, or extra fields without composing
      * recharts yourself. Ignored when `showTooltip` is false.
+     *
+     * On a segmented gauge it takes over from the built-in reading, and the payload
+     * it receives is the ring's synthetic pieces (`seg-2-track`, a length in
+     * degrees) rather than data rows — read the metric off `payload[0].payload`.
      */
     tooltipContent?: React.ComponentProps<typeof ChartTooltip>['content'];
+    /**
+     * Position of the value labels when `showLabels` is on. Defaults to
+     * `insideStart` — the labels sit inside each arc, and therefore render in the
+     * on-fill label token so they stay legible over the arc colour.
+     */
+    labelPosition?: PolarLabelPosition;
+    /**
+     * What each data label reads when `showLabels` is on — the value alone (the
+     * default), or the arc's name and its value. The name is the row's `nameKey`
+     * value, or the metric's `config` label in multi-metric mode.
+     */
+    labelFormat?: RadialBarChartLabelFormat;
 }
 declare const RadialBarChart: React.ForwardRefExoticComponent<Omit<RadialBarChartProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
 export { RadialBarChart };

package/dist/src/components/ui/scatter-chart/scatter-chart.d.ts

@@ -1,4 +1,4 @@
-import { ChartConfig, CartesianChartProps } from '../chart';
+import { ChartConfig, CartesianChartProps, ChartAnimationProps } from '../chart';
 import * as React from 'react';
 export type ScatterMarkerShape = 'circle' | 'cross' | 'diamond' | 'square' | 'star' | 'triangle' | 'wye';
 export interface ScatterSeries {
@@ -7,7 +7,7 @@ export interface ScatterSeries {
     /** This series' points — each row holds at least `xKey` and `yKey` (and `zKey` when used). */
     data: ReadonlyArray<Record<string, number>>;
 }
-export interface ScatterChartProps extends Omit<React.ComponentProps<'div'>, 'children'>, CartesianChartProps {
+export interface ScatterChartProps extends Omit<React.ComponentProps<'div'>, 'children'>, CartesianChartProps, ChartAnimationProps {
     /** One `<Scatter>` per entry — each with its own point array. Use a single entry for an ungrouped scatter. */
     series: ScatterSeries[];
     /**

package/dist/src/components/ui/timeline/index.d.ts

@@ -1 +1 @@
-export { Timeline, TimelineItem, type TimelineProps, type TimelineItemProps, type TimelineStatus, } from './timeline';
+export { Timeline, TimelineItem, type TimelineProps, type TimelineItemProps, type TimelineLevel, type TimelineMarkerColor, } from './timeline';

package/dist/src/components/ui/timeline/timeline.d.ts

@@ -1,37 +1,96 @@
 import { VariantProps } from 'class-variance-authority';
 import * as React from 'react';
+type TimelineVariant = 'default' | 'tree';
 declare const timelineVariants: (props?: ({
-    size?: "small" | "medium" | null | undefined;
-    density?: "compact" | "default" | null | undefined;
+    variant?: "tree" | "default" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 export interface TimelineProps extends React.ComponentProps<'ol'>, VariantProps<typeof timelineVariants> {
     /**
-     * `Timeline.Item`s — pass them as direct children (the connector auto-hides on
-     * the last one). Grouping/headings aren't supported as intervening children.
+     * Whether the list collapses. `default` never does; `tree` gives every row that
+     * has descendants a disclosure button ahead of its marker, which hides those
+     * descendants, and widens the indent step to reserve it on every row.
+     *
+     * Unrelated to `Timeline.Item`'s `collapsibleBody`, which folds a single card's
+     * own body and works the same under both variants.
+     */
+    variant?: TimelineVariant;
+    /**
+     * `Timeline.Item`s — pass them as direct children in visual order (never
+     * wrapped in a fragment, or their levels can't be read). Connectors are derived
+     * from the levels, so no row ever leaves a dangling line.
      */
     children?: React.ReactNode;
 }
-export type TimelineStatus = 'neutral' | 'info' | 'success' | 'warning' | 'danger' | 'critical';
+export type TimelineLevel = 1 | 2 | 3;
+/** The marker Avatar's color scheme (Figma ships the Timeline marker as Blue). */
+export type TimelineMarkerColor = 'blue' | 'gray' | 'green' | 'teal' | 'violet' | 'red' | 'yellow' | 'orange';
 export interface TimelineItemProps extends Omit<React.ComponentProps<'li'>, 'title'> {
+    /** Event title (the primary line in the card header). */
+    title: React.ReactNode;
     /** Event time — pass a `<time dateTime>` for an accessible, machine-readable stamp. */
     timestamp?: React.ReactNode;
-    /** Event title (the primary line). */
-    title: React.ReactNode;
-    /** Optional secondary description. */
+    /** Slot beside the title, before the timestamp — e.g. a `Tag`. */
+    tag?: React.ReactNode;
+    /** Optional secondary description under the title. */
     description?: React.ReactNode;
-    /** Semantic status — tints the marker (a subtle cue, never large blocks of text). */
-    status?: TimelineStatus;
-    /** Icon shown in a status-tinted marker badge instead of the plain dot. */
+    /** Icon rendered inside the marker Avatar. Takes precedence over `initials`. */
     icon?: React.ReactNode;
-    /** Metadata slot under the description — e.g. `Tag`s. */
-    metadata?: React.ReactNode;
-    /** Actions slot — e.g. a `Link` or `ButtonMenu`. */
-    actions?: React.ReactNode;
-    /** Emphasize this item as the current one (a ringed marker). */
-    current?: boolean;
-    /** Dim a non-applicable / inactive item. */
-    disabled?: boolean;
-    /** Expandable detail composed by the caller — e.g. an `Accordion`. */
+    /** Initials rendered inside the marker Avatar when no `icon` is given. */
+    initials?: string;
+    /** Marker Avatar color scheme. */
+    color?: TimelineMarkerColor;
+    /** Nesting depth (Figma `Nesting` L1-L3). Drives the indent only. */
+    level?: TimelineLevel;
+    /**
+     * Force the elbow joining this row to its parent's connector on or off (Figma's
+     * `Nesting` `-First`). Leave it unset — `Timeline` derives it from the levels,
+     * drawing it whenever this row is deeper than the one above it. Ignored at
+     * `level={1}`, which has no parent.
+     */
+    branchStart?: boolean;
+    /**
+     * Force the connector descending to the next row on or off (Figma
+     * `Connecting line`). Leave it unset — `Timeline` derives it from the levels,
+     * drawing it only when the next visible row is at this row's depth or deeper.
+     */
+    connector?: boolean;
+    /**
+     * Branch disclosure state (controlled). Only meaningful under `variant="tree"`
+     * on a row that has descendants — those rows get the control automatically.
+     */
+    expanded?: boolean;
+    /** Initial branch disclosure state when uncontrolled. */
+    defaultExpanded?: boolean;
+    /** Called with the requested disclosure state whenever the control is activated. */
+    onExpandedChange?: (expanded: boolean) => void;
+    /**
+     * Accessible name for the branch disclosure control — the one that drops this
+     * row's descendant rows. Distinct from `bodyToggleLabel` by default, because a
+     * tree row can carry both controls at once.
+     */
+    toggleLabel?: string;
+    /**
+     * Give this row's card a chevron at the trailing edge of its header that shows
+     * and hides the body (Figma's `Action Button`).
+     *
+     * Orthogonal to `variant`: it is the *card's* disclosure, not the timeline's, so
+     * it works the same in `default` and `tree` and a tree row can have both — the
+     * branch control drops the rows below, this one folds this card's own body.
+     * (It lives here only until `Card` grows the behaviour itself.)
+     */
+    collapsibleBody?: boolean;
+    /** Card-body disclosure state (controlled). */
+    bodyExpanded?: boolean;
+    /** Initial card-body disclosure state when uncontrolled. */
+    defaultBodyExpanded?: boolean;
+    /** Called with the requested card-body disclosure state. */
+    onBodyExpandedChange?: (expanded: boolean) => void;
+    /**
+     * Accessible name for the card-body disclosure control — the one that folds this
+     * row's own body. Distinct from `toggleLabel` by default.
+     */
+    bodyToggleLabel?: string;
+    /** Card body, rendered below a divider. */
     children?: React.ReactNode;
 }
 declare const TimelineItem: React.ForwardRefExoticComponent<Omit<TimelineItemProps, "ref"> & React.RefAttributes<HTMLLIElement>>;

package/dist/src/components/ui/treemap/index.d.ts

@@ -1 +1 @@
-export { Treemap, type TreemapProps } from './treemap';
+export { Treemap, type TreemapProps, type TreemapLabelAlign } from './treemap';

package/dist/src/components/ui/treemap/treemap.d.ts

@@ -1,16 +1,48 @@
-import { ChartTooltip, ChartConfig } from '../chart';
+import { ChartTooltip, ChartConfig, ChartAnimationProps, TickFormatter } from '../chart';
 import * as React from 'react';
+/**
+ * Where a cell's label block sits inside its rectangle. Named logically, not
+ * physically: the corner variants anchor to the tile's *start* edge, so they
+ * mirror under `dir="rtl"`. `bottom-start` is the design's placement; `center`
+ * is what the chart drew before the block had a second line.
+ */
+export type TreemapLabelAlign = 'bottom-start' | 'top-start' | 'center';
+/**
+ * Compose a cell's second line out of the caller's `secondaryKeys`. Empty and
+ * missing fields are skipped rather than printed as a gap, so one row without
+ * the field doesn't leave a dangling separator.
+ */
+export declare function treemapSecondaryLabel(options: {
+    row: Record<string, string | number>;
+    keys: readonly string[];
+    separator: string;
+    formatter?: TickFormatter;
+}): string | undefined;
 interface TreemapCellProps {
     x?: number;
     y?: number;
     width?: number;
     height?: number;
     name?: string;
+    /** The leaf's display name — its `config` label, stamped onto the row by `Treemap`. */
+    primaryLabel?: string;
+    /** The label's precomputed second line, stamped onto each row by `Treemap`. */
+    secondaryLabel?: string;
     showLabels?: boolean;
+    labelAlign?: TreemapLabelAlign;
 }
-export declare function TreemapCell({ x, y, width, height, name, showLabels, }: TreemapCellProps): import("react/jsx-runtime").JSX.Element;
-export interface TreemapProps extends Omit<React.ComponentProps<'div'>, 'children'> {
-    /** Row-per-leaf data. Each object holds the leaf's `nameKey` label + its `dataKey` numeric size. */
+export declare function TreemapCell({ x, y, width, height, name, primaryLabel, secondaryLabel, showLabels, labelAlign, }: TreemapCellProps): import("react/jsx-runtime").JSX.Element;
+export interface TreemapProps extends Omit<React.ComponentProps<'div'>, 'children'>, ChartAnimationProps {
+    /**
+     * Row-per-leaf data. Each object holds the leaf's `nameKey` label + its
+     * `dataKey` numeric size.
+     *
+     * `fill`, `primaryLabel` and `secondaryLabel` are reserved: the chart stamps
+     * them onto a copy of each row to carry the cell color and the two label lines
+     * through to the renderer (recharts hands the whole row to `content`, so
+     * anything the cell needs has to be on it). A row of your own carrying one of
+     * those names may end up driving what the tile paints.
+     */
     data: ReadonlyArray<Record<string, string | number>>;
     /**
      * Per-leaf map of `label` / `color`, keyed by the leaf's `nameKey` value
@@ -22,16 +54,44 @@ export interface TreemapProps extends Omit<React.ComponentProps<'div'>, 'childre
     /** Numeric field that sizes each leaf's rectangle. */
     dataKey: string;
     /**
-     * Label field that names each leaf (drives the on-cell label, tooltip, and
-     * `--color-<name>` lookup). Values should be unique and CSS-safe (they become
-     * part of a custom-property name).
+     * Label field that names each leaf (drives the on-cell label, legend, tooltip,
+     * and `--color-<name>` lookup). Values should be unique and CSS-safe (they
+     * become part of a custom-property name).
      */
     nameKey: string;
     /** Width-to-height ratio the tiling targets. */
     aspectRatio?: number;
-    /** Render each leaf's name inside its cell (when it fits). */
+    /** Render each leaf's label inside its cell (when it fits). */
     showLabels?: boolean;
+    /**
+     * Where a cell's label sits. Defaults to `bottom-start` — the design's
+     * placement, which keeps the label anchored to a tile corner as the tiling
+     * reflows. `top-start` anchors it to the opposite corner; `center` centers the
+     * block in the tile. The corner variants are named for the tile's *start* edge
+     * because they mirror under `dir="rtl"`.
+     */
+    labelAlign?: TreemapLabelAlign;
+    /**
+     * Fields whose values make up a second label line under the leaf's name — e.g.
+     * `[dataKey]` for the size, or `['size', 'count']` for a value and a count. The
+     * line is dropped on cells too short to hold it.
+     */
+    secondaryKeys?: readonly string[];
+    /**
+     * Format each secondary value. Receives the field's index in `secondaryKeys`
+     * as its second argument, so one formatter can cover fields of different kinds.
+     */
+    secondaryFormatter?: TickFormatter;
+    /** Separator drawn between multiple secondary values. */
+    secondarySeparator?: string;
     showTooltip?: boolean;
+    /**
+     * Render the legend — one entry per leaf. Off by default: a treemap labels its
+     * cells, so the legend is for the case where the tiles are too small to.
+     */
+    showLegend?: boolean;
+    /** Which edge the legend sits on. */
+    legendPos?: 'top' | 'bottom';
     /**
      * Replace the default tooltip. Pass a configured `ChartTooltipContent`
      * (imported from this library) — e.g. with a `formatter` / `labelFormatter` —

package/dist/src/index.d.ts

@@ -67,7 +67,6 @@ export * from './components/ui/progress-circle';
 export * from './components/ui/sankey-chart';
 export * from './components/ui/scatter-chart';
 export * from './components/ui/scroll-area';
-export * from './components/ui/search-global';
 export { InputText as Input, type InputTextProps as InputProps, } from './components/ui/input-text';
 export { InputSearch as Search, type InputSearchProps as SearchProps, } from './components/ui/input-search';
 export { InputTextArea as Textarea, type InputTextAreaProps as TextareaProps, } from './components/ui/input-text-area';