@dcs-tech/ui 0.2.0 → 0.3.0

package/dist/types/shared-types/src/ui/typography.types.d.ts

@@ -28,10 +28,6 @@ export interface TypographyProps extends DataAttributes {
     gutterBottom?: boolean;
     noWrap?: boolean;
     truncate?: boolean | TruncateConfig;
-    /**
-     * Explicit tooltip. Without it, `truncate.tooltip` supplies one from the text
-     * itself — and that one only appears when the text is genuinely clipped.
-     */
     tooltip?: TooltipProp;
     inline?: boolean;
     gradient?: GradientConfig;

package/dist/types/shared-web-ui/src/AppBar/AppBar.d.ts

@@ -2,24 +2,15 @@ import React from 'react';
 export type AppBarSize = 'small' | 'medium' | 'large';
 export type AppBarVariant = 'default' | 'transparent' | 'elevated';
 export interface AppBarProps {
-    /** Leading slot — logo, product name, a back button. */
     brand?: React.ReactNode;
-    /** Middle slot, takes the slack. Tabs, a search box, breadcrumbs. */
     children?: React.ReactNode;
-    /** Trailing slot, pinned to the end. */
     actions?: React.ReactNode;
     size?: AppBarSize;
     variant?: AppBarVariant;
-    /** Opt-in — see the note in the stylesheet on why it is not the default. */
     sticky?: boolean;
     className?: string;
     style?: React.CSSProperties;
     'aria-label'?: string;
 }
-/**
- * The top bar: three slots, a height and a rule. It deliberately holds no navigation logic of
- * its own — put `Tabs`, `Breadcrumbs` or a search trigger in the middle slot, which keeps one
- * implementation of each of those rather than a bar-flavoured copy.
- */
 declare const AppBar: React.FC<AppBarProps>;
 export default AppBar;

package/dist/types/shared-web-ui/src/ArrowKeyFocus/useArrowKeyFocus.d.ts

@@ -1,29 +1,10 @@
 export interface ArrowKeyFocusOptions {
-    /**
-     * Which arrows move. `both` (default) suits a button row: it wraps to a second line on a
-     * narrow screen, and there the user reaches for Up/Down.
-     */
     orientation?: 'horizontal' | 'vertical' | 'both';
-    /** Stepping past the last item lands on the first, and vice versa. Default true. */
     wrap?: boolean;
-    /** Home / End jump to the first / last item. Default true. */
     homeEnd?: boolean;
 }
 export interface ArrowKeyFocusHandlers {
-    /** Spread onto the element that CONTAINS the group (not onto each item). */
     onKeyDown: (e: React.KeyboardEvent<HTMLElement>) => void;
 }
-/**
- * Arrow keys move focus between the focusable items inside one container — a dialog's
- * button row, a toolbar, a segmented control. Tab and Shift+Tab are untouched: every item
- * stays an ordinary tab stop, the arrows are an addition, not a roving-tabindex replacement.
- *
- * Reads the items from the DOM on each key, so nothing per item has to be registered and
- * the group can be any mix of components (a client `SmartButton` next to a library `Button`).
- * A disabled or hidden item is skipped; a text field inside the group keeps its arrows.
- *
- *     const { onKeyDown } = useArrowKeyFocus();
- *     <div onKeyDown={onKeyDown}>{buttons}</div>
- */
 export declare function useArrowKeyFocus({ orientation, wrap, homeEnd, }?: ArrowKeyFocusOptions): ArrowKeyFocusHandlers;
 export default useArrowKeyFocus;

package/dist/types/shared-web-ui/src/Avatar/Avatar.d.ts

@@ -2,35 +2,21 @@ import React from 'react';
 export type AvatarSize = 'xs' | 'small' | 'medium' | 'large';
 export type AvatarShape = 'circle' | 'rounded' | 'square';
 export interface AvatarProps {
-    /** Image URL. Falls back to initials, then to `children`. */
     src?: string;
-    /** Used for the image's alt text and to derive initials when there is no `src`. */
     name?: string;
-    /** Override the derived initials. */
     initials?: string;
     size?: AvatarSize;
     shape?: AvatarShape;
-    /**
-     * Give the avatar a stable tint derived from `name`. Two people rarely collide, and the
-     * same person is always the same colour across screens.
-     */
     tinted?: boolean;
     children?: React.ReactNode;
     className?: string;
     style?: React.CSSProperties;
 }
-/**
- * A person or entity marker: image, initials, or custom content.
- *
- * Hookless, so it renders identically on a server. Sizes track the field heights, which is
- * what makes an avatar line up with an input or button placed beside it.
- */
 declare const Avatar: React.FC<AvatarProps>;
 export interface AvatarGroupProps {
     children?: React.ReactNode;
     className?: string;
     style?: React.CSSProperties;
 }
-/** Overlapping stack. Each disc is ringed in the page ground so they stay distinct. */
 export declare const AvatarGroup: React.FC<AvatarGroupProps>;
 export default Avatar;

package/dist/types/shared-web-ui/src/Badge/Badge.d.ts

@@ -4,25 +4,14 @@ export type BadgeVariant = 'tonal' | 'filled' | 'outlined';
 export type BadgeSize = 'xs' | 'small' | 'medium';
 export interface BadgeProps {
     children?: React.ReactNode;
-    /** Semantic colour. Default `'neutral'`. */
     color?: BadgeColor;
-    /** Default `'tonal'` — tinted ground, coloured text. Readable in both themes. */
     variant?: BadgeVariant;
     size?: BadgeSize;
-    /** Fully rounded ends. */
     pill?: boolean;
-    /** Leading status dot in the badge's own colour. */
     dot?: boolean;
     className?: string;
     style?: React.CSSProperties;
     title?: string;
 }
-/**
- * A short status marker.
- *
- * Hookless — renders identically on a server, so it stays eligible for a server-safe entry
- * point. Semantic colour comes from the shared tokens, so `error` here is the same red as an
- * error toast or a field message.
- */
 declare const Badge: React.FC<BadgeProps>;
 export default Badge;

package/dist/types/shared-web-ui/src/Breadcrumbs/Breadcrumbs.d.ts

@@ -1,70 +1,18 @@
 import React from 'react';
 import type { NavItem } from '../../../published/dcs-ui/src/publicTypes';
 export interface BreadcrumbsProps {
-    /**
-     * Root → current. Pass `findNavTrail(items, activeId)` from shared-logic and the crumbs are
-     * the same path the Sidebar highlights, by construction. The home crumb is NOT part of this.
-     */
     items: NavItem[];
-    /** Element for the linked crumbs — `Link`, `NavLink`, `a`. */
     as?: React.ElementType;
     onSelect?: (item: NavItem) => void;
-    /**
-     * The root crumb, rendered before the trail and never truncated. Defaults to a home icon
-     * linking to `/`; pass a `NavItem` to change the target, or `false` to drop it.
-     *
-     * It is on by DEFAULT because it does two jobs: a trail that starts mid-app has no visible
-     * way back to the top, and — since the switcher lives in the separator — without a crumb in
-     * front of it the FIRST real crumb has no separator and so no way to reach its siblings.
-     */
     home?: NavItem | false;
-    /**
-     * Render each crumb's `icon`. **Off by default.** The same `NavItem` tree feeds the Sidebar,
-     * where an icon per row earns its place, and the trail, where a row of little glyphs beside
-     * the home icon is noise — the labels already say it. Nothing to strip from the registry:
-     * the surface decides.
-     */
     showIcons?: boolean;
-    /** Default a chevron. */
     separator?: React.ReactNode;
-    /**
-     * Standalone row: own padding, min-height and bottom rule. Off by default, which is the
-     * inline form that sits in an `AppBar`. Turn it on where the trail is its own strip under
-     * the bar — the layout the client uses on mobile.
-     */
     bar?: boolean;
-    /**
-     * Collapse the middle into a menu past this many crumbs. First and last are always kept.
-     * `0` disables. Default 4.
-     */
     maxItems?: number;
-    /**
-     * Alternatives for a crumb. Return some and the separator BEFORE that crumb becomes a
-     * button opening them, so you can move sideways at any level instead of going back up and
-     * down again. With a `NavItem` tree it is the parent's `children`.
-     *
-     * `index` is the crumb's position in `items`; the home crumb is not counted, so index 0 is
-     * the first real crumb and its siblings are the top-level sections.
-     */
     siblingsOf?: (item: NavItem, index: number) => NavItem[];
     className?: string;
     style?: React.CSSProperties;
     'aria-label'?: string;
 }
-/**
- * The path to the current page, over the shared `NavItem` shape.
- *
- * Fed by `findNavTrail` — the same function the Sidebar uses for the active trail — so the two
- * cannot disagree about where you are.
- *
- * **The separator IS the sibling switcher.** It sits BEFORE each crumb and, where that crumb
- * has alternatives, is a button that opens them. One chevron per gap doing both jobs: a
- * separate switcher control next to each label puts two arrows between every pair of crumbs,
- * and a separator rendered AFTER each crumb leaves a dangling arrow past the last one.
- *
- * Long paths collapse in the MIDDLE, never the end: the first crumb (where am I in the app)
- * and the last (where am I now) carry the meaning, and truncating the tail would hide the very
- * crumb the user is looking at.
- */
 declare const Breadcrumbs: React.FC<BreadcrumbsProps>;
 export default Breadcrumbs;

package/dist/types/shared-web-ui/src/Card/Card.d.ts

@@ -3,31 +3,15 @@ export type CardVariant = 'outlined' | 'elevated' | 'flat';
 export type CardPadding = 'none' | 'small' | 'medium';
 export interface CardProps {
     children?: React.ReactNode;
-    /** Default `'outlined'`. */
     variant?: CardVariant;
-    /** Applied to the bands, not the root — see below. Default `'medium'`. */
     padding?: CardPadding;
     title?: React.ReactNode;
     subtitle?: React.ReactNode;
-    /** Trailing header content — a Badge, a menu button. */
     action?: React.ReactNode;
-    /** Footer band, right-aligned. */
     footer?: React.ReactNode;
-    /** Makes the whole card a button: hover, focus ring, keyboard activation. */
     onClick?: () => void;
     className?: string;
     style?: React.CSSProperties;
 }
-/**
- * A surface with optional header and footer bands.
- *
- * Padding lives on the BANDS, not the root, so a full-bleed child — a table, an image, an
- * embedded report — can sit flush between a padded header and footer without fighting the
- * card's own inset. `padding="none"` gives a bare surface.
- *
- * Hookless, so it renders identically on a server. With `onClick` it becomes a real
- * `<button>` rather than a div with a handler, which is what gets it keyboard activation and
- * a focus ring for free.
- */
 declare const Card: React.FC<CardProps>;
 export default Card;

package/dist/types/shared-web-ui/src/Charts/AnchoredMenu.d.ts

@@ -0,0 +1,17 @@
+import { type KeyboardEvent, type MouseEvent, type ReactElement, type ReactNode } from 'react';
+export interface AnchoredMenuItem {
+    value: string;
+    label: ReactNode;
+    icon?: ReactNode;
+}
+export interface AnchoredMenuProps {
+    trigger: ReactElement<{
+        onClick?: (e: MouseEvent) => void;
+        onKeyDown?: (e: KeyboardEvent) => void;
+    }>;
+    items: AnchoredMenuItem[];
+    onSelect: (value: string) => void;
+    'aria-label': string;
+    align?: 'start' | 'end';
+}
+export declare function AnchoredMenu({ trigger, items, onSelect, align, 'aria-label': ariaLabel }: AnchoredMenuProps): import("react").JSX.Element;

package/dist/types/shared-web-ui/src/Charts/BarList.d.ts

@@ -0,0 +1,12 @@
+import type { ReactNode } from 'react';
+import './Charts.css';
+import type { ChartDatum, ChartFormatProps, ChartLinkComponent, ChartSelectProps, ChartSeries } from './types';
+export interface BarListProps extends ChartFormatProps, ChartSelectProps<ChartDatum> {
+    data: ChartDatum[];
+    series: ChartSeries[];
+    ariaLabel: string;
+    title?: ReactNode;
+    linkAs?: ChartLinkComponent;
+    compact?: boolean;
+}
+export declare function BarList({ data, series, ariaLabel, title, linkAs: LinkAs, compact, onSelect, selected, ...format }: BarListProps): import("react").JSX.Element;

package/dist/types/shared-web-ui/src/Charts/CalendarHeatmap.d.ts

@@ -0,0 +1,17 @@
+import { type ReactNode } from 'react';
+import './Charts.css';
+import type { ChartFormatProps } from './types';
+export interface CalendarDay {
+    day: string;
+    count: number;
+}
+export interface CalendarHeatmapProps extends ChartFormatProps {
+    days: CalendarDay[];
+    ariaLabel: string;
+    title?: ReactNode;
+    onSelect?: (day: CalendarDay) => void;
+    selected?: string | null;
+    compact?: boolean;
+}
+export declare const weekdayNames: (locale?: string) => string[];
+export declare function CalendarHeatmap({ days, ariaLabel, title, onSelect, selected, compact, ...format }: CalendarHeatmapProps): import("react").JSX.Element;

package/dist/types/shared-web-ui/src/Charts/Chart.d.ts

@@ -0,0 +1,20 @@
+import { type ReactNode } from 'react';
+import './Charts.css';
+import { type ChartData, type ChartKind } from './chartData';
+import type { ChartFormatProps, ChartLinkComponent } from './types';
+export interface ChartProps extends ChartFormatProps {
+    data: ChartData;
+    as?: ChartKind;
+    offer?: readonly ChartKind[];
+    ariaLabel: string;
+    title?: ReactNode;
+    compact?: boolean;
+    height?: number;
+    size?: number;
+    onSelect?: (key: string) => void;
+    selected?: string | null;
+    linkAs?: ChartLinkComponent;
+    legend?: boolean;
+    onChartChange?: (kind: ChartKind) => void;
+}
+export declare function Chart({ data, as, offer, ariaLabel, title, compact, height, size, onSelect, selected, linkAs, onChartChange, legend, ...format }: ChartProps): import("react").JSX.Element;

package/dist/types/shared-web-ui/src/Charts/ChartIcon.d.ts

@@ -0,0 +1,5 @@
+import type { ChartKind } from './chartData';
+export declare function ChartIcon({ kind, size }: {
+    kind: ChartKind;
+    size?: number;
+}): import("react").JSX.Element;

package/dist/types/shared-web-ui/src/Charts/ChartImageMenu.d.ts

@@ -0,0 +1,4 @@
+import './Charts.css';
+import { type ChartImage } from './chartImage';
+export type ChartImageMenuProps = Omit<ChartImage, 'at'>;
+export declare function ChartImageMenu(image: ChartImageMenuProps): import("react").JSX.Element;

package/dist/types/shared-web-ui/src/Charts/ChartTable.d.ts

@@ -0,0 +1,8 @@
+import './Charts.css';
+import type { ChartDatum, ChartFormatProps, ChartSeries } from './types';
+export interface ChartTableProps extends Omit<ChartFormatProps, 'labels'> {
+    data: ChartDatum[];
+    series: ChartSeries[];
+    firstHeader: string;
+}
+export declare function ChartTable({ data, series, firstHeader, ...format }: ChartTableProps): import("react").JSX.Element;

package/dist/types/shared-web-ui/src/Charts/ChartTooltip.d.ts

@@ -0,0 +1,44 @@
+import { type KeyboardEvent, type PointerEvent, type ReactNode } from 'react';
+import { type ChartRect } from './pointer';
+type Steps = Partial<Record<'ArrowLeft' | 'ArrowRight' | 'ArrowUp' | 'ArrowDown', number>>;
+export interface ChartPointerOptions {
+    count: number;
+    pick: (x: number, y: number, box: DOMRect, plot: HTMLElement) => number | null;
+    anchor?: (index: number, plot: HTMLElement) => ChartRect | null;
+    keys?: Steps;
+    start?: number | null;
+    onPick?: (index: number) => void;
+}
+export interface ChartPointer {
+    active: number | null;
+    plotProps: {
+        ref: (el: HTMLElement | null) => void;
+        tabIndex: 0;
+        'data-chart-plot': '';
+        onPointerDown: (e: PointerEvent) => void;
+        onPointerMove: (e: PointerEvent) => void;
+        onPointerUp: () => void;
+        onPointerLeave: (e: PointerEvent) => void;
+        onClick: (e: {
+            clientX: number;
+            clientY: number;
+        }) => void;
+        onKeyDown: (e: KeyboardEvent) => void;
+        onBlur: () => void;
+    };
+    tooltip: (content: ReactNode) => ReactNode;
+}
+export declare function useChartPointer(options: ChartPointerOptions): ChartPointer;
+export declare function hitRect(plot: HTMLElement, index: number): ChartRect | null;
+export declare function hitRects(plot: HTMLElement): Array<ChartRect | null>;
+export declare function TooltipBody({ title, rows, note }: {
+    title?: ReactNode;
+    rows?: Array<{
+        key: string;
+        color?: string;
+        label: ReactNode;
+        value: ReactNode;
+    }>;
+    note?: ReactNode;
+}): import("react").JSX.Element;
+export {};

package/dist/types/shared-web-ui/src/Charts/ChartView.d.ts

@@ -0,0 +1,15 @@
+import type { ChartImageChart } from './chartImage';
+import type { ChartFormatProps, ChartLinkComponent } from './types';
+export interface ChartViewProps extends ChartFormatProps {
+    chart: ChartImageChart;
+    ariaLabel: string;
+    compact?: boolean;
+    height?: number;
+    size?: number;
+    onSelect?: (key: string) => void;
+    selected?: string | null;
+    linkAs?: ChartLinkComponent;
+    legend?: boolean;
+    onLegendCut?: (hidden: number) => void;
+}
+export declare function ChartView({ chart, ariaLabel, compact, height, size, onSelect, selected, linkAs, onLegendCut, legend, ...format }: ChartViewProps): import("react").JSX.Element;

package/dist/types/shared-web-ui/src/Charts/ColumnChart.d.ts

@@ -0,0 +1,15 @@
+import type { ReactNode } from 'react';
+import './Charts.css';
+import { type ColumnMode } from './geometry';
+import type { ChartDatum, ChartFormatProps, ChartSelectProps, ChartSeries } from './types';
+export interface ColumnChartProps extends ChartFormatProps, ChartSelectProps<ChartDatum> {
+    data: ChartDatum[];
+    series: ChartSeries[];
+    ariaLabel: string;
+    title?: ReactNode;
+    height?: number;
+    compact?: boolean;
+    mode?: ColumnMode;
+    legend?: boolean;
+}
+export declare function ColumnChart({ data, series, ariaLabel, title, height, compact, mode, legend, onSelect, selected, ...format }: ColumnChartProps): import("react").JSX.Element;

package/dist/types/shared-web-ui/src/Charts/Donut.d.ts

@@ -0,0 +1,14 @@
+import { type ReactNode } from 'react';
+import './Charts.css';
+import type { ChartFormatProps, ChartSelectProps, ChartSlice } from './types';
+export interface DonutProps extends ChartFormatProps, ChartSelectProps<ChartSlice> {
+    slices: ChartSlice[];
+    ariaLabel: string;
+    title?: ReactNode;
+    size?: number;
+    compact?: boolean;
+    variant?: 'donut' | 'pie';
+    onLegendCut?: (hidden: number) => void;
+    legend?: boolean;
+}
+export declare function Donut({ slices, ariaLabel, title, size, compact, variant, onLegendCut, legend, onSelect, selected, ...format }: DonutProps): import("react").JSX.Element;

package/dist/types/shared-web-ui/src/Charts/Funnel.d.ts

@@ -0,0 +1,10 @@
+import type { ReactNode } from 'react';
+import './Charts.css';
+import type { ChartFormatProps, ChartSelectProps, ChartSlice } from './types';
+export interface FunnelProps extends ChartFormatProps, ChartSelectProps<ChartSlice> {
+    steps: ChartSlice[];
+    ariaLabel: string;
+    title?: ReactNode;
+    compact?: boolean;
+}
+export declare function Funnel({ steps, ariaLabel, title, compact, onSelect, selected, ...format }: FunnelProps): import("react").JSX.Element;

package/dist/types/shared-web-ui/src/Charts/Gauge.d.ts

@@ -0,0 +1,15 @@
+import type { ReactNode } from 'react';
+import './Charts.css';
+import { type GaugeVariant } from './geometry';
+import type { ChartFormatProps, ChartProgressColor } from './types';
+export interface GaugeProps extends ChartFormatProps {
+    value: number;
+    total: number;
+    ariaLabel: string;
+    label?: ReactNode;
+    variant?: GaugeVariant;
+    color?: ChartProgressColor;
+    size?: number;
+    compact?: boolean;
+}
+export declare function Gauge({ value, total, ariaLabel, label, variant, color, size, compact, ...format }: GaugeProps): import("react").JSX.Element;

package/dist/types/shared-web-ui/src/Charts/Legend.d.ts

@@ -0,0 +1,6 @@
+import './Charts.css';
+import type { ChartFormatProps, ChartSeries } from './types';
+export interface LegendProps extends Pick<ChartFormatProps, 'labels'> {
+    series: ChartSeries[];
+}
+export declare function Legend({ series, labels }: LegendProps): import("react").JSX.Element | null;

package/dist/types/shared-web-ui/src/Charts/LineChart.d.ts

@@ -0,0 +1,13 @@
+import type { ReactNode } from 'react';
+import './Charts.css';
+import type { ChartDatum, ChartFormatProps, ChartSelectProps, ChartSeries } from './types';
+export interface LineChartProps extends ChartFormatProps, ChartSelectProps<ChartDatum> {
+    data: ChartDatum[];
+    series: ChartSeries[];
+    ariaLabel: string;
+    title?: ReactNode;
+    area?: boolean;
+    height?: number;
+    compact?: boolean;
+}
+export declare function LineChart({ data, series, ariaLabel, title, area, height, compact, onSelect, selected, ...format }: LineChartProps): import("react").JSX.Element;

package/dist/types/shared-web-ui/src/Charts/NumberTrend.d.ts

@@ -0,0 +1,21 @@
+import type { ReactNode } from 'react';
+import './Charts.css';
+import { type TrendGood } from './geometry';
+import type { ChartColor, ChartFormatProps } from './types';
+export interface NumberTrendPoint {
+    key?: string;
+    label: string;
+    value: number;
+}
+export interface NumberTrendProps extends ChartFormatProps {
+    value: number;
+    ariaLabel: string;
+    title?: ReactNode;
+    points?: NumberTrendPoint[];
+    current?: number;
+    previous?: number;
+    good?: TrendGood;
+    slot?: ChartColor;
+    compact?: boolean;
+}
+export declare function NumberTrend({ value, ariaLabel, title, points, current, previous, good, slot, compact, ...format }: NumberTrendProps): import("react").JSX.Element;

package/dist/types/shared-web-ui/src/Charts/Progress.d.ts

@@ -0,0 +1,12 @@
+import type { ReactNode } from 'react';
+import './Charts.css';
+import type { ChartFormatProps, ChartProgressColor } from './types';
+export interface ProgressProps extends ChartFormatProps {
+    value: number;
+    total: number;
+    ariaLabel: string;
+    label?: ReactNode;
+    color?: ChartProgressColor;
+    compact?: boolean;
+}
+export declare function Progress({ value, total, ariaLabel, label, color, compact, ...format }: ProgressProps): import("react").JSX.Element;

package/dist/types/shared-web-ui/src/Charts/StackedBar.d.ts

@@ -0,0 +1,11 @@
+import { type ReactNode } from 'react';
+import './Charts.css';
+import type { ChartFormatProps, ChartSelectProps, ChartSlice } from './types';
+export interface StackedBarProps extends ChartFormatProps, ChartSelectProps<ChartSlice> {
+    slices: ChartSlice[];
+    ariaLabel: string;
+    title?: ReactNode;
+    compact?: boolean;
+    onLegendCut?: (hidden: number) => void;
+}
+export declare function StackedBar({ slices, ariaLabel, title, compact, onLegendCut, onSelect, selected, ...format }: StackedBarProps): import("react").JSX.Element;

package/dist/types/shared-web-ui/src/Charts/Treemap.d.ts

@@ -0,0 +1,12 @@
+import { type ReactNode } from 'react';
+import './Charts.css';
+import { type TreemapNode } from './geometry';
+import type { ChartFormatProps, ChartSelectProps } from './types';
+export interface TreemapProps extends ChartFormatProps, ChartSelectProps<TreemapNode> {
+    nodes: TreemapNode[];
+    ariaLabel: string;
+    title?: ReactNode;
+    height?: number;
+    compact?: boolean;
+}
+export declare function Treemap({ nodes, ariaLabel, title, height, compact, onSelect, selected, ...format }: TreemapProps): import("react").JSX.Element;

package/dist/types/shared-web-ui/src/Charts/chartData.d.ts

@@ -0,0 +1,69 @@
+import type { ChartImageChart } from './chartImage';
+import type { TrendGood } from './geometry';
+import type { ChartLabels } from './labels';
+import type { ChartColor, ChartProgressColor, ChartSeries } from './types';
+export interface ChartValueCount {
+    key?: string;
+    label: string;
+    fullLabel?: string;
+    count?: number;
+    counts?: Record<string, number>;
+    slot?: ChartColor;
+    selectable?: boolean;
+    href?: string;
+    children?: Array<{
+        key?: string;
+        label: string;
+        count: number;
+    }>;
+}
+export interface ChartPeriodCount {
+    key: string;
+    label: string;
+    fullLabel?: string;
+    count?: number;
+    counts?: Record<string, number>;
+    selectable?: boolean;
+}
+export interface ChartStepCount {
+    key: string;
+    label: string;
+    count: number;
+    slot?: ChartColor;
+    selectable?: boolean;
+}
+export type ChartData = {
+    type: 'values';
+    values: ChartValueCount[];
+    series?: ChartSeries[];
+} | {
+    type: 'time';
+    period: 'day' | 'week' | 'month';
+    points: ChartPeriodCount[];
+    series?: ChartSeries[];
+} | {
+    type: 'part';
+    label: string;
+    value: number;
+    total: number;
+    color?: ChartProgressColor;
+} | {
+    type: 'steps';
+    steps: ChartStepCount[];
+} | {
+    type: 'number';
+    value: number;
+    points?: Array<{
+        key?: string;
+        label: string;
+        value: number;
+    }>;
+    previous?: number;
+    good?: TrendGood;
+};
+export type ChartKind = 'donut' | 'pie' | 'bars' | 'stacked' | 'treemap' | 'columns' | 'line' | 'area' | 'grouped' | 'calendar' | 'bar' | 'gauge' | 'ring' | 'funnel' | 'number' | 'numberTrend';
+export declare function chartsFor(data: ChartData): ChartKind[];
+export declare function chartOfData(data: ChartData, as?: ChartKind, offer?: readonly ChartKind[]): ChartKind;
+export type ChartDataWords = Pick<ChartLabels, 'count' | 'rest'>;
+export declare const countSeries: (label: string) => ChartSeries[];
+export declare function toChart(data: ChartData, as: ChartKind | undefined, words: ChartDataWords, offer?: readonly ChartKind[]): ChartImageChart;