@galaxy-io/dls 1.6.1 → 2.0.0

package/dist/buttons/ButtonGroup.d.ts

@@ -0,0 +1,38 @@
+import { type AriaAttributes, type CSSProperties, type ReactNode } from "react";
+import { Orientation } from "../theme/enums.js";
+export interface ButtonGroupProps extends Omit<AriaAttributes, "aria-label"> {
+    /**
+     * The buttons: `Button`, `CopyButton`, or another Button preset, all of one `size`. Falsy
+     * children are skipped.
+     */
+    children?: ReactNode;
+    /**
+     * Join the buttons into one segmented control: no gap, square inner corners, one hairline at
+     * each seam.
+     * @default false
+     */
+    isAttached?: boolean;
+    /**
+     * Lay the buttons out in a row or a column.
+     * @default Orientation.HORIZONTAL
+     */
+    orientation?: Orientation;
+    /**
+     * Stretch the group to the parent's width. In a row, the buttons share the width equally.
+     * @default false
+     */
+    fillWidth?: boolean;
+    /** Accessible name of the group, such as "Text formatting". Set it when the set has a meaning beyond its buttons' own names. */
+    ariaLabel?: string;
+    /** DOM id on the root. */
+    id?: string;
+    /** Any `data-*` attribute, forwarded to the root. */
+    [dataAttribute: `data-${string}`]: string | number | boolean | undefined;
+    /** Extra class on the root. */
+    className?: string;
+    /** Inline style on the root; only for setting CSS custom properties. */
+    style?: CSSProperties;
+}
+/** A set of related buttons, spaced or attached into one segmented control. */
+declare const ButtonGroup: import("react").ForwardRefExoticComponent<ButtonGroupProps & import("react").RefAttributes<HTMLDivElement>>;
+export default ButtonGroup;

package/dist/buttons/ButtonGroup.js

@@ -0,0 +1,68 @@
+import { Orientation } from "../theme/enums.js";
+/* empty css                      */
+import { styled } from "@linaria/react";
+import { forwardRef } from "react";
+import { jsx } from "react/jsx-runtime";
+import { cx } from "@linaria/core";
+//#region src/buttons/ButtonGroup.tsx
+/**
+* Puts a set of related buttons in one row (or column) and names them as a group
+* (`role="group"`). By default the buttons sit `space[8]` apart. With `isAttached` they join into
+* one segmented control: no gap, square inner corners, and one shared hairline at each seam (each
+* later child's leading border is removed), so only the outer corners stay round.
+*
+* ButtonGroup holds no value and pushes nothing into its children: each child is an ordinary
+* `Button` (or a preset such as `CopyButton`) with its own `size`, `variant` and `isDisabled`. It
+* adds no wrapper around a child, so every child's root element is a direct child of the group.
+* The child rules are written at (0,2,0) specificity, so they win over Button's single-class root
+* rules whatever the stylesheet order.
+*
+* Not a single choice among options (`ToggleInput`), not a toolbar with arrow keys, and not a
+* split button (`Button dropdown`, Dropdown row).
+*/
+/** Static rules. `isolation: isolate` keeps the focused child's `z-index: 1` inside the group. */
+var Root = /*#__PURE__*/ styled("div")({
+	name: "Root",
+	class: "gx-ButtonGroup-r1i5m4j6",
+	propsAsIs: false
+});
+/** Row or column. In a column the buttons stretch to the widest child's width. */
+var BUTTON_GROUP_ORIENTATION_TO_CSS_MAP = {
+	[Orientation.HORIZONTAL]: "gx-ButtonGroup-Orientation_HORIZONTAL-okrb96p",
+	[Orientation.VERTICAL]: "gx-ButtonGroup-Orientation_VERTICAL-o1imubde"
+};
+/** Not attached: a fixed gap (a different spacing is a `Flex`). */
+var DETACHED_CSS = "gx-ButtonGroup-DETACHED_CSS-d1l4w5po";
+/**
+* Attached: every child after the first loses its leading border and leading corners, every
+* child before the last loses its trailing corners, so each seam is one hairline (the previous
+* child's trailing border). The focused child is lifted so its focus ring is never painted over
+* by the next sibling. The `0` values and the local `z-index: 1` are literals, not scale steps.
+*/
+var BUTTON_GROUP_ORIENTATION_TO_ATTACHED_CSS_MAP = {
+	[Orientation.HORIZONTAL]: "gx-ButtonGroup-Orientation_HORIZONTAL-o1a8lwt0",
+	[Orientation.VERTICAL]: "gx-ButtonGroup-Orientation_VERTICAL-o1p86yuh"
+};
+/** `fillWidth`: the group takes the parent's width. */
+var FILL_WIDTH_CSS = "gx-ButtonGroup-FILL_WIDTH_CSS-f1n78ece";
+/** `fillWidth` in a row: the buttons share the width equally and their labels truncate. */
+var BUTTON_GROUP_ORIENTATION_TO_FILL_WIDTH_CSS_MAP = {
+	[Orientation.HORIZONTAL]: "gx-ButtonGroup-Orientation_HORIZONTAL-o12vzedd",
+	[Orientation.VERTICAL]: ""
+};
+/** A set of related buttons, spaced or attached into one segmented control. */
+var ButtonGroup = forwardRef(function ButtonGroup({ children, isAttached = false, orientation = Orientation.HORIZONTAL, fillWidth = false, ariaLabel, id, className, style, ...rest }, ref) {
+	return /* @__PURE__ */ jsx(Root, {
+		...rest,
+		ref,
+		id,
+		role: "group",
+		"aria-label": ariaLabel ?? rest["aria-label"],
+		className: cx(BUTTON_GROUP_ORIENTATION_TO_CSS_MAP[orientation], isAttached ? BUTTON_GROUP_ORIENTATION_TO_ATTACHED_CSS_MAP[orientation] : DETACHED_CSS, fillWidth && FILL_WIDTH_CSS, fillWidth && BUTTON_GROUP_ORIENTATION_TO_FILL_WIDTH_CSS_MAP[orientation], className),
+		style,
+		children
+	});
+});
+ButtonGroup.displayName = "ButtonGroup";
+//#endregion
+export { ButtonGroup as default };

package/dist/buttons/CopyButton.d.ts

@@ -0,0 +1,77 @@
+import { type AriaAttributes, type CSSProperties, type FocusEventHandler, type MouseEvent, type MouseEventHandler } from "react";
+import { ButtonSize, ButtonVariant } from "./Button.js";
+/** Every CopyButton prop except the accessible-name pair (`label` / `ariaLabel`). */
+export interface CopyButtonBaseProps extends AriaAttributes {
+    /** The text written to the clipboard on press. */
+    value: string;
+    /**
+     * Button mode: solid, bordered, transparent, or muted fill. Copying is never destructive, so
+     * `ERROR` is a type error.
+     * @default ButtonVariant.TERTIARY
+     */
+    variant?: Exclude<ButtonVariant, ButtonVariant.ERROR>;
+    /**
+     * Button rung: 20 / 24 / 32 / 36 / 40px tall.
+     * @default ButtonSize.MEDIUM
+     */
+    size?: ButtonSize;
+    /**
+     * Blocks the copy, shows Button's disabled look, and disables the hint.
+     * @default false
+     */
+    isDisabled?: boolean;
+    /**
+     * Stretch to the parent's width. Content stays centered.
+     * @default false
+     */
+    fillWidth?: boolean;
+    /**
+     * Called on press, right after the copy starts (it does not wait for the clipboard). Call
+     * `event.stopPropagation()` here to keep a surrounding clickable row from also firing.
+     */
+    onClick?: (event: MouseEvent<HTMLButtonElement>) => void;
+    /** Focus passthrough to the button. */
+    onFocus?: FocusEventHandler<HTMLButtonElement>;
+    /** Blur passthrough to the button. */
+    onBlur?: FocusEventHandler<HTMLButtonElement>;
+    /** Pointer-enter passthrough to the button. */
+    onMouseEnter?: MouseEventHandler<HTMLButtonElement>;
+    /** Pointer-leave passthrough to the button. */
+    onMouseLeave?: MouseEventHandler<HTMLButtonElement>;
+    /** DOM id on the button. */
+    id?: string;
+    /** Any `data-*` attribute, forwarded to the button. */
+    [dataAttribute: `data-${string}`]: string | number | boolean | undefined;
+    /** Extra class on the button. */
+    className?: string;
+    /** Inline style on the button; only for setting CSS custom properties. */
+    style?: CSSProperties;
+}
+/** A visible label, optionally with an accessible name that starts with it. */
+interface CopyButtonLabelledProps {
+    /**
+     * Visible text after the copy icon ("Copy link"). It does not change to "Copied"; the tooltip
+     * confirms. Omit it for an icon-only button and set `ariaLabel` instead.
+     */
+    label: string;
+    /** Accessible name. With a `label`, it must start with the visible label text. */
+    ariaLabel?: string;
+}
+/** No visible label: the accessible name is required. */
+interface CopyButtonUnlabelledProps {
+    /**
+     * Visible text after the copy icon ("Copy link"). It does not change to "Copied"; the tooltip
+     * confirms. Omit it for an icon-only button and set `ariaLabel` instead.
+     */
+    label?: undefined;
+    /**
+     * Accessible name, required without a `label`; it also fills the hover hint. Name what is
+     * copied ("Copy API key").
+     */
+    ariaLabel: string;
+}
+/** CopyButton props. Without a `label`, `ariaLabel` is required by the type. */
+export type CopyButtonProps = CopyButtonBaseProps & (CopyButtonLabelledProps | CopyButtonUnlabelledProps);
+/** Copies `value` on press, swaps the icon to a check, and confirms with "Copied". */
+declare const CopyButton: import("react").ForwardRefExoticComponent<CopyButtonProps & import("react").RefAttributes<HTMLButtonElement>>;
+export default CopyButton;

package/dist/buttons/CopyButton.js

@@ -0,0 +1,65 @@
+import VisuallyHidden from "../a11y/VisuallyHidden.js";
+import Portal from "../layout/Portal.js";
+import Tooltip from "../tooltip/Tooltip.js";
+import Button, { ButtonSize, ButtonVariant } from "./Button.js";
+import { useClipboard } from "../hooks/useClipboard.js";
+import { forwardRef, useState } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+import { CheckIcon, CopyIcon } from "@phosphor-icons/react";
+//#region src/buttons/CopyButton.tsx
+/**
+* Copies one string to the clipboard when pressed and confirms it: the copy icon turns into a
+* check and a "Copied" tooltip shows for the `useClipboard` timeout (1.5s), while a polite live
+* region announces "Copied" to screen readers. When the clipboard API is missing or refuses,
+* nothing changes: CopyButton never claims a copy that did not happen.
+*
+* A preset over `Button` (as `Bold` and `Code` are over `Span`): it renders a real `Button` with
+* the icon, the click handler and a controlled `Tooltip` filled in, and takes Button's own
+* `ButtonSize` and `ButtonVariant` (import them from `buttons/Button`). It has no styles of its
+* own. The tooltip bubble and the live region render through `Portal`, so CopyButton's only DOM
+* node in place is the `<button>` (a valid `ButtonGroup` child).
+*
+* A read-only field with a copy button is `CopyInput`, which composes `TextInput` and this.
+*/
+/** The confirmation text in the tooltip and the live region (fixed English, as Button's "(opens in a new tab)"). */
+var COPIED_LABEL = "Copied";
+/** Copies `value` on press, swaps the icon to a check, and confirms with "Copied". */
+var CopyButton = forwardRef(function CopyButton(props, ref) {
+	const { value, label, ariaLabel, variant = ButtonVariant.TERTIARY, size = ButtonSize.MEDIUM, isDisabled = false, fillWidth = false, onClick, ...rest } = props;
+	const { copy, hasCopied } = useClipboard();
+	const [isHintOpen, setIsHintOpen] = useState(false);
+	const nameProps = props.label !== void 0 ? {
+		label: props.label,
+		...props.ariaLabel === void 0 ? {} : { ariaLabel: props.ariaLabel }
+	} : { ariaLabel: props.ariaLabel };
+	const handleClick = (event) => {
+		copy(value);
+		onClick?.(event);
+	};
+	return /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(Tooltip, {
+		body: hasCopied ? COPIED_LABEL : label === void 0 ? ariaLabel : "",
+		isOpen: hasCopied || isHintOpen,
+		onOpenChange: setIsHintOpen,
+		isDisabled,
+		"aria-hidden": true,
+		children: /* @__PURE__ */ jsx(Button, {
+			...rest,
+			...nameProps,
+			ref,
+			icon: hasCopied ? CheckIcon : CopyIcon,
+			variant,
+			size,
+			isDisabled,
+			fillWidth,
+			type: "button",
+			onClick: handleClick
+		})
+	}), /* @__PURE__ */ jsx(Portal, { children: /* @__PURE__ */ jsx(VisuallyHidden, {
+		"aria-live": "polite",
+		"aria-atomic": "true",
+		children: hasCopied ? COPIED_LABEL : ""
+	}) })] });
+});
+CopyButton.displayName = "CopyButton";
+//#endregion
+export { CopyButton as default };

package/dist/charts/AreaChart.d.ts

@@ -0,0 +1,49 @@
+/**
+ * AreaChart plots series as filled areas over a categorical x-axis: volume over time, or, with
+ * `isStacked`, how a total splits into parts over time. Each area is a flat, translucent fill
+ * with its line on top, colored from `ChartPalette`. A `null` reading breaks
+ * that area's top edge; in a stack it contributes 0, so the total stays a total.
+ *
+ * A preset over LineChart's engine (`LineChartRoot`): hover, keyboard, tooltip, cursor,
+ * selection, gaps and `ChartGroupProvider` sync behave exactly as on LineChart. The chart fills
+ * its parent (2:1 when the parent has no definite height). Needs the optional peers `d3-scale`
+ * and `d3-shape`.
+ */
+import { type ReactElement, type RefAttributes } from "react";
+import { type LineChartPointDatum } from "./LineChart.js";
+import { type BaseCartesianChartProps, type ChartCurve, type ChartSeriesStyles } from "./types.js";
+/** One area. Same shape as a line, without the dash (an area is never a forecast). */
+export interface AreaChartAreaDatum<TMetric extends string> {
+    /** Which metric this area draws; a key of `series`. */
+    metric: TMetric;
+    /** Points in category order; `y: null` is a gap. */
+    points: LineChartPointDatum[];
+}
+/** AreaChart's own props; the shared chart props follow (`BaseCartesianChartProps`). */
+interface AreaChartOwnProps<TMetric extends string> {
+    /** Label and color for every metric, keyed by metric. `TMetric` is inferred from these keys only. */
+    series: ChartSeriesStyles<TMetric>;
+    /** One entry per area, drawn in array order (the first is at the back, or at the bottom of the stack). Areas may be sparse. */
+    areas: AreaChartAreaDatum<NoInfer<TMetric>>[];
+    /** Category order along the x-axis. Pass it whenever areas are sparse. @default the union of every area's `x`, first-seen order */
+    categories?: string[];
+    /**
+     * How the top edge of each area is drawn.
+     * @default ChartCurve.SMOOTH
+     */
+    curve?: ChartCurve;
+    /**
+     * Stack the areas so the top edge is the running total; off, areas overlap from the zero baseline.
+     * @default false
+     */
+    isStacked?: boolean;
+}
+export type AreaChartProps<TMetric extends string> = AreaChartOwnProps<TMetric> & BaseCartesianChartProps<NoInfer<TMetric>>;
+/**
+ * The public, generic call signature (`TMetric` inferred from `series`). Never called: it only
+ * types the default export. An arrow function so react-docgen-typescript reads the props.
+ */
+declare const AREA_CHART_SIGNATURE: <TMetric extends string>(_props: AreaChartProps<TMetric> & RefAttributes<HTMLDivElement>) => ReactElement | null;
+/** Filled series over a categorical x-axis, overlapping or stacked. */
+declare const AreaChart: typeof AREA_CHART_SIGNATURE;
+export default AreaChart;

package/dist/charts/AreaChart.js

@@ -0,0 +1,31 @@
+import { ChartKind } from "./types.js";
+import { LineChartFill, LineChartRoot } from "./LineChart.js";
+import { forwardRef } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/charts/AreaChart.tsx
+/**
+* AreaChart plots series as filled areas over a categorical x-axis: volume over time, or, with
+* `isStacked`, how a total splits into parts over time. Each area is a flat, translucent fill
+* with its line on top, colored from `ChartPalette`. A `null` reading breaks
+* that area's top edge; in a stack it contributes 0, so the total stays a total.
+*
+* A preset over LineChart's engine (`LineChartRoot`): hover, keyboard, tooltip, cursor,
+* selection, gaps and `ChartGroupProvider` sync behave exactly as on LineChart. The chart fills
+* its parent (2:1 when the parent has no definite height). Needs the optional peers `d3-scale`
+* and `d3-shape`.
+*/
+var AreaChartInner = forwardRef(function AreaChart({ areas, isStacked = false, ...rest }, ref) {
+	return /* @__PURE__ */ jsx(LineChartRoot, {
+		...rest,
+		ref,
+		lines: areas,
+		fill: LineChartFill.AREA,
+		isStacked,
+		kind: ChartKind.AREA
+	});
+});
+AreaChartInner.displayName = "AreaChart";
+/** Filled series over a categorical x-axis, overlapping or stacked. */
+var AreaChart = AreaChartInner;
+//#endregion
+export { AreaChart as default };

package/dist/charts/BarChart.d.ts

@@ -1,77 +1,64 @@
-import { BarChartNormalization } from "./types";
-import type { BarChartGroupDatum, BaseCartesianChartProps, ChartSelectionEvent, ChartSelectionInput, ChartSeriesStyles, ChartSize } from "./types";
-export type BarChartProps<TMetric extends string, TComponentKey extends string = string> = BaseCartesianChartProps & ChartSize & {
-    /**
-     * Presentation for every metric, keyed by metric.
-     *
-     * `TMetric` is inferred from these keys and from nowhere else — every data
-     * prop below wraps it in `NoInfer` — which is what turns a mistyped metric
-     * into a compile error instead of a silently missing bar.
-     */
+import { type ReactElement, type RefAttributes } from "react";
+import type { Hex } from "../theme/tokens/types.js";
+import { type BaseCartesianChartProps, type ChartPalette, type ChartSeriesStyles } from "./types.js";
+/** How bar values are scaled before drawing. Not a grouped/stacked switch: that comes from the data. */
+export declare enum BarChartNormalization {
+    /** Plot raw values. The default. */
+    NONE = "NONE",
+    /** Scale each bar's components to fill the axis: a 100% stacked chart. */
+    PERCENT = "PERCENT"
+}
+/** One stacked segment of a bar. A bar with a single component is a plain, unstacked bar. */
+export interface BarChartComponentDatum<TComponentKey extends string = string> {
+    /** Identifies this segment; unique within its bar. Names it in the legend when bars are stacked. */
+    key: TComponentKey;
+    /** Name shown in the tooltip and, when bars are stacked, the legend. */
+    label: string;
+    /** Segment magnitude. Negative values stack below the zero baseline. */
+    value: number;
+    /** Palette slot; defaults to the component's position in the automatic order. */
+    color?: ChartPalette;
+    /** Raw color. Discouraged: it does not follow the theme. Wins over `color`. */
+    hex?: Hex;
+}
+/** One bar in a group: a stack of components for one metric. */
+export interface BarChartBarDatum<TMetric extends string, TComponentKey extends string = string> {
+    /** Which metric this bar draws; a key of `series`. */
+    metric: TMetric;
+    /** Segments, stacked in array order outward from the baseline. */
+    components: BarChartComponentDatum<TComponentKey>[];
+}
+/** One category on the x-axis, holding one bar per metric. */
+export interface BarChartGroupDatum<TMetric extends string, TComponentKey extends string = string> {
+    /** Category label under the group; also the raw key that selection and sync match on. */
+    label: string;
+    /** Bars, left to right in array order. */
+    bars: BarChartBarDatum<TMetric, TComponentKey>[];
+}
+/** BarChart's own props; the shared chart props follow (`BaseCartesianChartProps`). */
+interface BarChartOwnProps<TMetric extends string, TComponentKey extends string> {
+    /** Label and color for every metric, keyed by metric. `TMetric` is inferred from these keys only. */
     series: ChartSeriesStyles<TMetric>;
-    /** Categories along the x-axis, left to right. */
+    /** Categories left to right; each holds one bar per metric, each bar a stack of components. */
     groups: BarChartGroupDatum<NoInfer<TMetric>, NoInfer<TComponentKey>>[];
-    /** @default BarChartNormalization.NONE */
+    /**
+     * `PERCENT` scales every bar to fill the axis (a 100% stacked chart); the tooltip still shows raw values.
+     * @default BarChartNormalization.NONE
+     */
     normalization?: BarChartNormalization;
-    /** Tint the active category's full band, marking the hover position even
-     * where there is no data. @default true */
-    showCursor?: boolean;
     /**
-     * Floor, in px, for how short a *stack segment* may render — so a series
-     * that is a rounding error next to its neighbours still leaves a visible
-     * mark instead of disappearing. `0`, the default, draws segments at their
-     * true size.
-     *
-     * Opt-in because it is a lie, and a small one is worth being deliberate
-     * about: the pixels a sliver gains are taken from the other segments in the
-     * same stack, in proportion to how much slack each has. The stack's total
-     * height, its cap position and every value in the tooltip stay exactly
-     * right — only the split between segments shifts, by at most a couple of
-     * pixels per rescued sliver. Reach for it when presence/absence is the
-     * thing being read (an error series, a small cohort); leave it off when the
-     * chart is being read for proportion.
-     *
-     * Ignored on unstacked bars, which already have a 2px floor — there is no
-     * neighbour to take from, so it costs nothing there. Ignored, too, when a
-     * stack is so crowded that honouring it would pin every segment to the
-     * minimum: at that point the bar would stop describing its data, and the
-     * chart is better off saying so. Fold the tail into an "Other" component
-     * instead.
-     *
+     * Smallest rendered height, in px, of a stack segment, taken from its neighbors so the stack's total stays exact. Use it when presence matters more than proportion.
      * @default 0
      */
     minSegmentLength?: number;
-    /**
-     * Fires when a bar segment or a category is clicked. Supplying it is what
-     * makes the plot clickable.
-     *
-     * A click resolves to the finest thing under the pointer: a segment reports
-     * its own key and value, while the gutters, the plot above a short bar and
-     * the hairline seams between segments fall back to the category alone.
-     *
-     * `seriesKey` follows the same rule the legend and the mute axis do —
-     * components when the chart is stacked, metrics when it is not — so all
-     * three always name the same dimension.
-     */
-    onSelect?: (event: ChartSelectionEvent<NoInfer<TMetric> | NoInfer<TComponentKey>>) => void;
-    /**
-     * Which marks read as selected. Matching bars hold full strength, the rest
-     * recede, and each selected category takes a persistent band — the hover
-     * tint one step firmer, held rather than previewed.
-     *
-     * Presentational and never written by the chart: the state belongs to
-     * whatever the selection is filtering, so the two cannot drift apart. Feed
-     * an {@link onSelect} event straight back, or describe a broader set —
-     * `{ seriesKey: "failed" }` selects every failure on the axis.
-     */
-    selection?: ChartSelectionInput<NoInfer<TMetric> | NoInfer<TComponentKey>>;
-};
+}
+export type BarChartProps<TMetric extends string, TComponentKey extends string = string> = BarChartOwnProps<TMetric, TComponentKey> & BaseCartesianChartProps<NoInfer<TMetric> | NoInfer<TComponentKey>>;
 /**
- * Bar chart with a three-level data model.
- *
- * Grouping and stacking are properties of the data rather than a mode: several
- * `bars` in a group render side by side, several `components` in a bar stack,
- * and a chart doing both at once needs no extra configuration.
+ * The public, generic call signature (`TMetric` inferred from `series`; `TComponentKey` given
+ * explicitly to type component keys). Never called: it only types the default export. An arrow
+ * function so react-docgen-typescript reads the props.
  */
-declare const BarChart: <TMetric extends string, TComponentKey extends string = string>({ series, groups, width, height, fillWidth, fillHeight, aspectRatio, margin, normalization, showCursor, minSegmentLength, onSelect, selection, valueUnit, valueFormatter, labelFormatter, valueDomain, categoryLabelMode, categoryAxisTitle, valueAxisTitle, showGrid, showLegend, legendMaxItems, noTooltip, tooltipRenderer, tooltipMaxItems, isLoading, contentWhenEmpty, ariaLabel, ariaDescription, }: BarChartProps<TMetric, TComponentKey>) => import("react").JSX.Element;
+declare const BAR_CHART_SIGNATURE: <TMetric extends string, TComponentKey extends string = string>(_props: BarChartProps<TMetric, TComponentKey> & RefAttributes<HTMLDivElement>) => ReactElement | null;
+/** Vertical bars over a categorical x-axis: grouped, stacked, or both. */
+declare const BarChart: typeof BAR_CHART_SIGNATURE;
 export default BarChart;