@dcs-tech/ui 0.2.0 → 0.4.0

package/dist/summaryChartData-Djo73zb8.js

@@ -0,0 +1,81 @@
+"use client";
+import { Tt as e, U as t } from "./geometry-CG2nOEnw.js";
+// src/components/DataTable/summary/summaryChartData.ts
+function n(e, t) {
+	return {
+		type: "values",
+		values: t.map((t) => ({
+			key: t.key,
+			label: t.label,
+			count: t.count,
+			...t.others ? {
+				slot: "rest",
+				selectable: !1
+			} : e.card.slots?.[t.key] === void 0 ? {} : { slot: t.slot },
+			...t.children ? { children: t.children.map((e) => ({
+				key: e.key,
+				label: e.label,
+				count: e.count
+			})) } : {}
+		}))
+	};
+}
+function r(e) {
+	switch (e.kind) {
+		case "unavailable": return {
+			type: "number",
+			value: 0
+		};
+		case "value": return {
+			type: "number",
+			value: e.value ?? 0,
+			...e.trend ? {
+				points: e.trend.points.map((e) => ({
+					key: e.key,
+					label: e.fullLabel,
+					value: e.count
+				})),
+				previous: e.trend.previous,
+				good: e.card.trend?.good
+			} : {}
+		};
+		case "ratio": return {
+			type: "part",
+			label: e.card.title,
+			value: e.value ?? 0,
+			total: e.total ?? 0,
+			color: e.card.color
+		};
+		case "trend": {
+			let t = e.periods ?? [], n = e.series.length > 0;
+			return {
+				type: "time",
+				period: e.card.period,
+				...n ? { series: e.series.map((e) => ({
+					key: e.key,
+					label: e.label,
+					slot: e.slot
+				})) } : {},
+				points: t.map((e) => ({
+					key: e.key,
+					label: e.label,
+					fullLabel: e.fullLabel,
+					...n ? { counts: e.split ?? {} } : { count: e.count }
+				}))
+			};
+		}
+		case "funnel": return {
+			type: "steps",
+			steps: (e.steps ?? []).map((e) => ({
+				key: e.key,
+				label: e.label,
+				count: e.count,
+				slot: e.slot,
+				selectable: e.selectable
+			}))
+		};
+		case "breakdown": return n(e, e.buckets ?? []);
+	}
+}
+var i = (t) => e(t.card), a = (e, n) => t(r(e), i(e), n);
+export { a as n, i as r, n as t };

package/dist/types/components/AppBar/AppBar.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+export type AppBarSize = 'small' | 'medium' | 'large';
+export type AppBarVariant = 'default' | 'transparent' | 'elevated';
+export interface AppBarProps {
+    brand?: React.ReactNode;
+    children?: React.ReactNode;
+    actions?: React.ReactNode;
+    size?: AppBarSize;
+    variant?: AppBarVariant;
+    sticky?: boolean;
+    className?: string;
+    style?: React.CSSProperties;
+    'aria-label'?: string;
+}
+declare const AppBar: React.FC<AppBarProps>;
+export default AppBar;

package/dist/types/components/ArrowKeyFocus/useArrowKeyFocus.d.ts

@@ -0,0 +1,10 @@
+export interface ArrowKeyFocusOptions {
+    orientation?: 'horizontal' | 'vertical' | 'both';
+    wrap?: boolean;
+    homeEnd?: boolean;
+}
+export interface ArrowKeyFocusHandlers {
+    onKeyDown: (e: React.KeyboardEvent<HTMLElement>) => void;
+}
+export declare function useArrowKeyFocus({ orientation, wrap, homeEnd, }?: ArrowKeyFocusOptions): ArrowKeyFocusHandlers;
+export default useArrowKeyFocus;

package/dist/types/components/Avatar/Avatar.d.ts

@@ -0,0 +1,22 @@
+import React from 'react';
+export type AvatarSize = 'xs' | 'small' | 'medium' | 'large';
+export type AvatarShape = 'circle' | 'rounded' | 'square';
+export interface AvatarProps {
+    src?: string;
+    name?: string;
+    initials?: string;
+    size?: AvatarSize;
+    shape?: AvatarShape;
+    tinted?: boolean;
+    children?: React.ReactNode;
+    className?: string;
+    style?: React.CSSProperties;
+}
+declare const Avatar: React.FC<AvatarProps>;
+export interface AvatarGroupProps {
+    children?: React.ReactNode;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export declare const AvatarGroup: React.FC<AvatarGroupProps>;
+export default Avatar;

package/dist/types/{shared-web-ui/src → components}/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/components/Breadcrumbs/Breadcrumbs.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import type { NavItem } from '../../core/types';
+export interface BreadcrumbsProps {
+    items: NavItem[];
+    as?: React.ElementType;
+    onSelect?: (item: NavItem) => void;
+    home?: NavItem | false;
+    showIcons?: boolean;
+    separator?: React.ReactNode;
+    bar?: boolean;
+    maxItems?: number;
+    siblingsOf?: (item: NavItem, index: number) => NavItem[];
+    className?: string;
+    style?: React.CSSProperties;
+    'aria-label'?: string;
+}
+declare const Breadcrumbs: React.FC<BreadcrumbsProps>;
+export default Breadcrumbs;

package/dist/types/{shared-web-ui/src → components}/Button/Button.d.ts

@@ -1,4 +1,4 @@
 import React from 'react';
-import type { ButtonProps } from '../../../published/dcs-ui/src/publicTypes';
+import type { ButtonProps } from '../../core/types';
 declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLElement>>;
 export default Button;

package/dist/types/{shared-web-ui/src → components}/Button/ButtonGroup.d.ts

@@ -1,4 +1,4 @@
 import React from 'react';
-import type { ButtonGroupProps } from '../../../published/dcs-ui/src/publicTypes';
+import type { ButtonGroupProps } from '../../core/types';
 declare const ButtonGroup: React.FC<ButtonGroupProps>;
 export default ButtonGroup;

package/dist/types/{shared-web-ui/src → components}/Button/ButtonGroupContext.d.ts

@@ -1,3 +1,3 @@
-import type { ButtonGroupContextValue } from '../../../published/dcs-ui/src/publicTypes';
+import type { ButtonGroupContextValue } from '../../core/types';
 export declare const ButtonGroupCtx: import("react").Context<ButtonGroupContextValue | null>;
 export declare function useButtonGroup(): ButtonGroupContextValue | null;

package/dist/types/{shared-web-ui/src → components}/Button/index.d.ts

@@ -1,3 +1,3 @@
 export { default as Button } from './Button';
 export { default as ButtonGroup } from './ButtonGroup';
-export type { ButtonProps, ButtonGroupProps, ButtonVariant, ButtonSize, ButtonColor, ButtonShape, LoadingPosition, GroupOrientation, ButtonGroupContextValue, } from '../../../published/dcs-ui/src/publicTypes';
+export type { ButtonProps, ButtonGroupProps, ButtonVariant, ButtonSize, ButtonColor, ButtonShape, LoadingPosition, GroupOrientation, ButtonGroupContextValue, } from '../../core/types';

package/dist/types/components/Card/Card.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+export type CardVariant = 'outlined' | 'elevated' | 'flat';
+export type CardPadding = 'none' | 'small' | 'medium';
+export interface CardProps {
+    children?: React.ReactNode;
+    variant?: CardVariant;
+    padding?: CardPadding;
+    title?: React.ReactNode;
+    subtitle?: React.ReactNode;
+    action?: React.ReactNode;
+    footer?: React.ReactNode;
+    onClick?: () => void;
+    className?: string;
+    style?: React.CSSProperties;
+}
+declare const Card: React.FC<CardProps>;
+export default Card;

package/dist/types/components/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/components/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/components/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/components/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/components/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/components/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/components/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/components/Charts/ChartTooltip.d.ts

@@ -0,0 +1,58 @@
+import { type FocusEvent, 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;
+    focusable?: (index: number) => boolean;
+}
+export interface ChartItemProps {
+    'data-hit': number;
+    role?: 'button';
+    tabIndex?: 0 | -1;
+    'aria-pressed'?: boolean;
+    'aria-disabled'?: true;
+}
+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;
+        onFocus: (e: FocusEvent) => void;
+        onBlur: (e: FocusEvent) => void;
+    };
+    pickable: boolean;
+    item: (index: number, state?: {
+        pressed?: boolean;
+        disabled?: boolean;
+    }) => ChartItemProps;
+    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/components/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/components/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/components/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/components/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/components/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/components/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/components/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/components/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/components/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/components/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/components/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/components/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;