h2o-library 1.7.1 → 2.0.0

package/dist/charts/components/src/multi-select/multi-select.d.ts

@@ -0,0 +1,49 @@
+import "./multi-select.css";
+import React from "react";
+/**
+ * A selectable item in the dropdown list; `value` must be unique across `options`.
+ * @property {string} label - Shown in the list and in selected tags.
+ * @property {string} value - Stable id stored in the selection array.
+ */
+export interface MultiSelectOption {
+    label: string;
+    value: string;
+}
+/**
+ * **Controlled** multi-select: `value` is the full set of selected `{ label, value }` objects, not just keys.
+ *
+ * @property {MultiSelectOption[]} options - Full catalog; filtered when `showSearch` is on.
+ * @property {MultiSelectOption[]} value - Current selection (order preserved for tags).
+ * @property {(options: MultiSelectOption[]) => void} onChange - Emits the new array on any change.
+ * @property {number} [maxSelectedOptions] - Hard cap; further picks are ignored when reached.
+ * @property {boolean} [showSearch] - When `true`, shows a search field in the panel. Default `true`.
+ * @property {boolean} [showSelectAll] - When `true`, exposes a select-all control in the list. Default `false`.
+ */
+interface MultiSelectProps {
+    options: MultiSelectOption[];
+    value: MultiSelectOption[];
+    onChange: (options: MultiSelectOption[]) => void;
+    placeholder?: string;
+    label?: string;
+    error?: string;
+    note?: string;
+    disabled?: boolean;
+    size?: "sm" | "md" | "lg";
+    className?: string;
+    containerClassName?: string;
+    maxSelectedOptions?: number;
+    showClear?: boolean;
+    toggleLabel?: string;
+    onToggle?: (checked: boolean) => void;
+    showSearch?: boolean;
+    showSelectAll?: boolean;
+}
+/**
+ * Field that opens a list with checkboxes, optional search, select-all, max cap, and selected rows as `Tag`s.
+ *
+ * @param {MultiSelectProps} props - Controlled `value` / `onChange` plus `options`.
+ * @param {React.Ref<HTMLDivElement>} ref - Container ref.
+ * @returns {React.ReactElement} Trigger, open panel, and tag stack.
+ */
+export declare const MultiSelect: React.ForwardRefExoticComponent<MultiSelectProps & React.RefAttributes<HTMLDivElement>>;
+export {};

package/dist/charts/components/src/pagination/pagination.d.ts

@@ -0,0 +1,33 @@
+import "./pagination.css";
+/**
+ * Page/limit UI: **controlled** `currentPage`, `perPage`, and `totalPages`.
+ *
+ * @property {number} currentPage - 1-based index of the active page.
+ * @property {number} totalPages - Total page count from the server or client math.
+ * @property {number} perPage - Rows per page (synced with `Dropdown` for `onPerPageChange`).
+ * @property {number} [totalItems] - Optional; shown in the summary line when provided.
+ * @property {{label: string, value: number}[]} [perPageOptions] - Dropdown entries; default presets 10–50.
+ * @property {(page: number) => void} onPageChange - Called with the new 1-based page.
+ * @property {(perPage: number) => void} onPerPageChange - Called when the user changes page size.
+ */
+interface PaginationProps {
+    currentPage: number;
+    totalPages: number;
+    perPage: number;
+    totalItems?: number;
+    perPageOptions?: {
+        label: string;
+        value: number;
+    }[];
+    onPageChange: (page: number) => void;
+    onPerPageChange: (perPage: number) => void;
+    className?: string;
+}
+/**
+ * Renders first/prev/next/last, numeric page window, and a per-page `Dropdown` when `perPageOptions` is set.
+ *
+ * @param {PaginationProps} props - Page + limit state and handlers.
+ * @returns {JSX.Element} The pagination toolbar.
+ */
+export declare function Pagination({ currentPage, totalPages, perPage, totalItems, perPageOptions, onPageChange, onPerPageChange, className, }: PaginationProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/charts/components/src/popover/popover.d.ts

@@ -0,0 +1,53 @@
+import "./popover.css";
+import type { ReactNode } from "react";
+import type React from "react";
+/**
+ * **Controlled** headless popover: `isOpen` / `setIsOpen` and children compose with `PopOverTrigger` + `PopOverContent`.
+ *
+ * @property {boolean} isOpen - When `true`, `PopOverContent` computes position and listens for outside close.
+ * @property {(isOpen: boolean) => void} setIsOpen - Toggle or close the panel (same contract as `useState` setter).
+ * @property {React.ReactNode} children - Must include one `PopOverTrigger` and one `PopOverContent` (siblings under this provider).
+ * @property {"left"|"right"} [alignment] - Horizontal align of the panel vs the trigger. Default `"left"`.
+ * @property {number} [offset] - Gap in px between trigger bottom and panel top. Default `8`.
+ */
+interface PopOverProps {
+    isOpen: boolean;
+    setIsOpen: (isOpen: boolean) => void;
+    children: React.ReactNode;
+    alignment?: "left" | "right";
+    /** Gap in px between trigger and floating panel. Default: 8. */
+    offset?: number;
+    className?: string;
+}
+/**
+ * React context root for a floating popover: shares `isOpen` and trigger ref with trigger + content.
+ *
+ * @param {PopOverProps} props - `isOpen` / `setIsOpen` and `children` tree.
+ * @returns {JSX.Element} The provider and optional `className` on the wrapper `div`.
+ */
+export declare const PopOver: ({ children, isOpen, setIsOpen, alignment, offset, className, }: PopOverProps) => import("react/jsx-runtime").JSX.Element;
+/**
+ * The toggling surface for a popover: click / Enter / Space flips `isOpen`; `ref` targets this `div` for anchoring.
+ *
+ * @param {object} props
+ * @param {ReactNode} props.children - Trigger contents (e.g. a `Button`).
+ * @param {string} [props.className] - Extra classes on the trigger `div`.
+ * @returns {JSX.Element} A `div` with `role="button"`, focusable, and `aria-expanded` bound to `isOpen`.
+ */
+export declare const PopOverTrigger: ({ children, className, }: {
+    children: ReactNode;
+    className?: string;
+}) => import("react/jsx-runtime").JSX.Element;
+/**
+ * Portal-mounted panel: positions under (or flips above) the trigger, closes on outside click and Escape.
+ *
+ * @param {object} props
+ * @param {ReactNode} props.children - Panel body.
+ * @param {string} [props.className] - Extra classes on the floating `div`.
+ * @returns {JSX.Element | null} The fixed panel when `isOpen`, else `null`.
+ */
+export declare const PopOverContent: ({ children, className, }: {
+    children: ReactNode;
+    className?: string;
+}) => JSX.Element | null;
+export {};

package/dist/charts/components/src/radio/radio.d.ts

@@ -0,0 +1,31 @@
+import "./radio.css";
+import React from "react";
+import type { TooltipPosition } from "../../../types";
+/**
+ * Single radio control: extends `HTMLInputElement` except `type` and design-system `size`.
+ *
+ * @property {string} [label] - Legend next to the circle.
+ * @property {string} [description] - Subtext under the label in card mode.
+ * @property {boolean} [isCard] - Large card layout vs inline. Default `false`.
+ * @property {"sm"|"md"|"lg"} [size] - Visual scale. Default `"md"`.
+ */
+interface RadioProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "type" | "size"> {
+    label?: string;
+    description?: string;
+    containerClassName?: string;
+    error?: string;
+    note?: string;
+    size?: "sm" | "md" | "lg";
+    isCard?: boolean;
+    tooltip?: string;
+    tooltipPosition?: TooltipPosition;
+}
+/**
+ * Radio `input` with optional label row, validation text, and info tooltip on the label.
+ *
+ * @param {RadioProps} props - Native `checked`/`onChange` plus label and `isCard`.
+ * @param {React.Ref<HTMLInputElement>} ref - Forwarded to the `<input type="radio">`.
+ * @returns {React.ReactElement} Wrapper `div` with `label` and optional error/note.
+ */
+export declare const Radio: React.ForwardRefExoticComponent<RadioProps & React.RefAttributes<HTMLInputElement>>;
+export {};

package/dist/charts/components/src/radio-group/radio-group.d.ts

@@ -0,0 +1,42 @@
+import "./radio-group.css";
+import type { IconType, TooltipPosition } from "../../../types";
+/**
+ * One entry in a `RadioGroup` `options` array.
+ * @property {string} label - Option title.
+ * @property {string} value - Emitted to `onChange` when selected.
+ * @property {import("../../../types").IconType} [icon] - Optional leading icon.
+ * @property {"active"|"inactive"} [dot] - Optional status dot style when no icon.
+ */
+export interface RadioOption {
+    label: string;
+    value: string;
+    icon?: IconType;
+    dot?: "active" | "inactive";
+    disabled?: boolean;
+    tooltip?: string;
+    tooltipPosition?: TooltipPosition;
+}
+/**
+ * **Controlled** radio group: `selected` is the `value` of the chosen `RadioOption`.
+ *
+ * @property {RadioOption[]} options - The full set of choices.
+ * @property {string} selected - Current `value` (must match one option, or be managed by the parent for empty state).
+ * @property {(value: string) => void} onChange - Called with the new `value` on selection.
+ */
+interface RadioGroupProps {
+    options: RadioOption[];
+    selected: string;
+    onChange: (value: string) => void;
+    ariaLabel?: string;
+    size?: "sm" | "md" | "lg";
+    className?: string;
+    optionClassName?: string;
+}
+/**
+ * Horizontal/vertical list of option “cards” with shared `role="radiogroup"` and keyboard roving.
+ *
+ * @param {RadioGroupProps} props - `options`, `selected`, and `onChange` are required.
+ * @returns {JSX.Element} The radiogroup container and one button per option.
+ */
+export declare const RadioGroup: ({ options, selected, onChange, ariaLabel, size, className, optionClassName, }: RadioGroupProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/charts/components/src/segmented-toggle/segmented-toggle.d.ts

@@ -0,0 +1,50 @@
+import "./segmented-toggle.css";
+import type React from "react";
+import type { SVGProps } from "react";
+import type { IconType } from "../../../types";
+/** Extra attributes forwarded to `Icon` (per segment). */
+type SegmentedToggleIconProps = Omit<SVGProps<SVGSVGElement>, "children"> & {
+    size?: number;
+    strokeWidth?: number;
+};
+/**
+ * One segment in a `SegmentedToggle` row.
+ *
+ * @property {string} label - Button text.
+ * @property {string} value - Emitted to `onChange` when that segment is selected.
+ * @property {IconType} [icon] - Optional leading icon (per-option `iconProps` fine-tune the `Icon`).
+ */
+export type SegmentedToggleOption = {
+    label: string;
+    value: string;
+    icon?: IconType;
+    iconProps?: SegmentedToggleIconProps;
+    labelProps?: React.HTMLAttributes<HTMLSpanElement>;
+    disabled?: boolean;
+};
+/**
+ * **Controlled** `selected` + `onChange` string; `options` render as a connected button group.
+ *
+ * @property {SegmentedToggleOption[]} options - Segments; may include per-option `disabled`.
+ * @property {string} selected - Current `value` (must match an option for correct pressed state).
+ * @property {(value: string) => void} onChange - Fires with the option `value` on click or keyboard.
+ * @property {string} [ariaLabel] - Accessible name for the `role="radiogroup"` container.
+ */
+interface SegmentedToggleProps {
+    options: SegmentedToggleOption[];
+    size?: "sm" | "md" | "lg";
+    className?: string;
+    optionClassName?: string;
+    selected: string;
+    onChange: (value: string) => void;
+    disabled?: boolean;
+    ariaLabel?: string;
+}
+/**
+ * Horizontal iOS-style segmented control with optional icons, keyboard roving, and `aria-pressed` sync.
+ *
+ * @param {SegmentedToggleProps} props - `options`, `selected`, and `onChange` are required.
+ * @returns {JSX.Element} The `radiogroup` container and one button per option.
+ */
+export declare function SegmentedToggle({ options, size, className, optionClassName, selected, onChange, disabled, ariaLabel, }: SegmentedToggleProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/charts/components/src/side-panel/side-panel.d.ts

@@ -0,0 +1,36 @@
+import "./side-panel.css";
+import type React from "react";
+/**
+ * Slide-in panel (drawer) props: **controlled** `isOpen`; focus trap and Escape close when open.
+ *
+ * @property {boolean} isOpen - When `true`, mounts the portal and traps focus.
+ * @property {() => void} onClose - Called from the close button and Escape.
+ * @property {"left"|"right"} [position] - Slide origin. Default `"right"`.
+ * @property {"sm"|"md"|"lg"} [size] - Panel width preset. Default `"md"`.
+ * @property {React.ReactNode} children - Main scrollable body between header and optional `footer`.
+ */
+interface SidePanelProps {
+    isOpen: boolean;
+    onClose: () => void;
+    position?: "left" | "right";
+    size?: "sm" | "md" | "lg";
+    title?: string;
+    description?: string;
+    children: React.ReactNode;
+    footer?: React.ReactNode;
+    className?: string;
+    titleContainerClassName?: string;
+    titleClassName?: string;
+    descriptionClassName?: string;
+    closeButtonClassName?: string;
+    headerClassName?: string;
+    contentClassName?: string;
+}
+/**
+ * Off-canvas panel with title/description, default close control, and optional `footer` slot.
+ *
+ * @param {SidePanelProps} props - `isOpen` / `onClose` plus layout BEM class overrides.
+ * @returns {JSX.Element | null} Portal content when `isOpen`, else `null`.
+ */
+export declare const SidePanel: ({ isOpen, onClose, position, size, title, description, children, footer, className, titleContainerClassName, titleClassName, descriptionClassName, closeButtonClassName, headerClassName, contentClassName, }: SidePanelProps) => JSX.Element | null;
+export {};

package/dist/charts/components/src/skeleton/skeleton.d.ts

@@ -0,0 +1,15 @@
+import "./skeleton.css";
+import type { HTMLAttributes } from "react";
+type SkeletonVariant = "text" | "rectangular" | "circular";
+interface SkeletonProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    variant?: SkeletonVariant;
+    width?: string | number;
+    height?: string | number;
+    size?: "sm" | "md" | "lg";
+    animate?: boolean;
+}
+/**
+ * Placeholder block with a muted surface and a subtle shimmer aligned to the design tokens.
+ */
+export declare const Skeleton: ({ variant, width, height, size, animate, className, style, role, "aria-label": ariaLabel, ...props }: SkeletonProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/charts/components/src/slider/slider.d.ts

@@ -0,0 +1,46 @@
+import "./slider.css";
+import type React from "react";
+import type { TooltipPosition } from "../../../types";
+export type SliderMark = {
+    value: number;
+    label?: string;
+};
+type BaseSliderProps = {
+    min?: number;
+    max?: number;
+    step?: number;
+    disabled?: boolean;
+    label?: string;
+    tooltip?: string;
+    tooltipPosition?: TooltipPosition;
+    note?: string;
+    error?: string;
+    containerClassName?: string;
+    className?: string;
+    marks?: SliderMark[];
+    showExtents?: boolean;
+    showValue?: boolean;
+    showTooltip?: boolean;
+    name?: string;
+    formatValue?: (value: number) => string;
+} & Omit<React.HTMLAttributes<HTMLDivElement>, "onChange" | "defaultValue" | "value">;
+type SingleSliderProps = BaseSliderProps & {
+    range?: false;
+    value?: number;
+    defaultValue?: number;
+    onValueChange?: (value: number) => void;
+};
+type RangeSliderProps = BaseSliderProps & {
+    range: true;
+    value?: [number, number];
+    defaultValue?: [number, number];
+    onValueChange?: (value: [number, number]) => void;
+    minDistance?: number;
+};
+type SliderProps = SingleSliderProps | RangeSliderProps;
+/**
+ * Single-thumb or dual-thumb range slider with keyboard support, optional marks,
+ * tooltips, and field chrome (label, error, note) consistent with `Input`.
+ */
+export declare function Slider(props: SliderProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/charts/components/src/table/table-utils.d.ts

@@ -0,0 +1,2 @@
+export declare const isInteractiveElement: (element: HTMLElement | null) => boolean;
+export declare const hasInteractiveParent: (element: HTMLElement | null, stopAt: HTMLElement | null) => boolean;

package/dist/charts/components/src/table/table.d.ts

@@ -0,0 +1,78 @@
+import "./table.css";
+import React from "react";
+/**
+ * Sort state for a column: ascending, descending, or unsorted.
+ * @type {("asc"|"desc"|null)}
+ */
+export type SortDirection = "asc" | "desc" | null;
+/**
+ * One column: accessor `key` maps to `row[key]`, with optional `render` for custom cells.
+ * @template T - Row type.
+ * @property {string} key - Object key on each row, or a synthetic key for custom columns.
+ * @property {boolean} [sortable] - When `true` and `onSort` is provided, header is clickable.
+ * @property {function(unknown, T): React.ReactNode} [render] - If omitted, `String(row[key])` is used.
+ */
+export interface TableColumn<T> {
+    key: string;
+    label: string;
+    sortable?: boolean;
+    minWidth?: string;
+    maxWidth?: string;
+    width?: string;
+    render?: (value: unknown, row: T) => React.ReactNode;
+}
+/**
+ * @template T - Row object type; keys should match `TableColumn.key` where possible.
+ * Full data grid: sort, optional row selection, column edit popover (drag/drop + visibility), pagination, loading.
+ *
+ * @property {TableColumn<T>[]} columns - Column defs; can include a synthetic `__selection` for checkboxes.
+ * @property {T[]} data - Rows to render; order is preserved.
+ * @property {string} [sortKey] - **Controlled** sort column; use with `sortDirection` and `onSort`.
+ * @property {SortDirection} [sortDirection] - Current direction for `sortKey`.
+ * @property {boolean} [columnsEditable] - Enables “Edit columns” popover. Default `false`.
+ * @property {string[]} [visibleColumns] - **Controlled** list of column keys to show. Pair with `onVisibleColumnsChange`.
+ * @property {T[]} [selectedRows] - **Controlled** selected rows. Pair with `onSelectionChange` and `rowKey`.
+ * @property {keyof T} [rowKey] - Unique key field on `T` for selection identity. Often `"id"`.
+ * @property {number} [currentPage] - 1-based page index when `Pagination` is used.
+ * @property {string} [maxHeight] - Max height of the scrollable table body.
+ */
+interface TableProps<T extends Record<string, unknown>> {
+    columns: TableColumn<T>[];
+    data: T[];
+    isLoading?: boolean;
+    className?: string;
+    containerClassName?: string;
+    rowHeight?: string;
+    sortKey?: string;
+    sortDirection?: SortDirection;
+    columnsEditable?: boolean;
+    currentPage?: number;
+    totalPages?: number;
+    perPage?: number;
+    perPageOptions?: {
+        label: string;
+        value: number;
+    }[];
+    onSort?: (key: string, direction: SortDirection) => void;
+    onPageChange?: (page: number) => void;
+    onPerPageChange?: (perPage: number) => void;
+    onVisibleColumnsChange?: (keys: string[]) => void;
+    maxHeight?: string;
+    visibleColumns?: string[];
+    maxVisibleColumns?: number;
+    defaultVisibleColumns?: string[];
+    trailingColumns?: string[];
+    selectedRows?: T[];
+    onSelectionChange?: (rows: T[]) => void;
+    rowKey?: keyof T;
+    onRowClick?: (row: T, rowIndex: number) => void;
+}
+/**
+ * Renders a full-featured table: headers, body, optional selection column, sort indicators, edit-columns popover, and pagination.
+ *
+ * @template T - Row record type.
+ * @param {object} props - Column definitions, data, and optional controlled sorting / pagination / selection.
+ * @returns {JSX.Element} The table shell, scroll region, and optional `Pagination` / `Loader`.
+ */
+export declare function Table<T extends Record<string, unknown>>({ columns, data, isLoading, className, rowHeight, sortKey, sortDirection, onSort, currentPage, totalPages, perPage, perPageOptions, onPageChange, onPerPageChange, maxHeight, columnsEditable, containerClassName, visibleColumns, onVisibleColumnsChange, maxVisibleColumns, defaultVisibleColumns, trailingColumns, selectedRows, onSelectionChange, rowKey, onRowClick, }: TableProps<T>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/charts/components/src/tabs/tabs.d.ts

@@ -0,0 +1,35 @@
+import "./tabs.css";
+/**
+ * One entry in a `Tabs` `tabs` list.
+ * @property {string} value - Emitted to `onChange` when the tab is activated.
+ */
+export type TabItem = {
+    label: string;
+    value: string;
+    disabled?: boolean;
+};
+/**
+ * **Controlled** tab strip: `selectedTab` must match a `TabItem.value` for the active state.
+ *
+ * @property {TabItem[]} tabs - Tab metadata; `disabled` items are skipped in keyboard nav.
+ * @property {string} selectedTab - Current `value` of the active tab.
+ * @property {(value: string) => void} onChange - Fires with the new tab `value` on click or keyboard.
+ * @property {"sm"|"md"|"lg"} [size] - Size token for the tab list. Default `"md"`.
+ */
+interface TabsProps {
+    tabs: TabItem[];
+    selectedTab: string;
+    onChange: (tab: string) => void;
+    ariaLabel?: string;
+    size?: "sm" | "md" | "lg";
+    tabClassName?: string;
+    className?: string;
+}
+/**
+ * Renders a `tablist` with one `button` per tab, roving tabindex, and arrow-key / Home / End support.
+ *
+ * @param {TabsProps} props - `tabs` / `selectedTab` / `onChange` plus `ariaLabel` for the list.
+ * @returns {JSX.Element} The horizontal tab list.
+ */
+export declare const Tabs: ({ tabs, selectedTab, onChange, ariaLabel, size, tabClassName, className, }: TabsProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/charts/components/src/tag/tag.d.ts

@@ -0,0 +1,26 @@
+import "./tag.css";
+import React from "react";
+/**
+ * Removable label chip with primary/secondary styles and sizes.
+ *
+ * @property {string} label - Visible text and remove `aria-label` source.
+ * @property {"primary"|"secondary"} [variant] - Color scheme. Default `"primary"`.
+ * @property {"sm"|"md"|"lg"} [size] - Typographic and hit-target scale. Default `"md"`.
+ * @property {() => void} onRemove - Fires when the user clicks the “×” control.
+ */
+type TagProps = {
+    label: string;
+    variant?: "primary" | "secondary";
+    size?: "sm" | "md" | "lg";
+    onRemove: () => void;
+    className?: string;
+};
+/**
+ * A dismissible tag used in multi-selects and filter lists; forwards ref to the root `div`.
+ *
+ * @param {TagProps} props - `label`, `onRemove`, and presentation props.
+ * @param {React.Ref<HTMLDivElement>} ref - Root element ref.
+ * @returns {React.ReactElement} The tag row and remove button.
+ */
+export declare const Tag: React.ForwardRefExoticComponent<TagProps & React.RefAttributes<HTMLDivElement>>;
+export {};

package/dist/charts/components/src/textarea/textarea.d.ts

@@ -0,0 +1,33 @@
+import "./textarea.css";
+import React from "react";
+import type { TooltipPosition } from "../../../types";
+/**
+ * Props for `Textarea`: extends `HTMLTextAreaElement` attributes (omits legacy HTML `size`).
+ *
+ * @property {string} [label] - Optional field label with optional info tooltip.
+ * @property {boolean} [showClear] - Renders clear when non-empty. Default `false`.
+ * @property {string} [note] - Helper line under the field.
+ * @property {string} [error] - Error line; invalid styling when set.
+ * @property {number} [maxLength] - When set, shows a live character counter vs this cap (e.g., 12/200).
+ * @property {"none"|"vertical"} [resize] - CSS resize mode. Default `"none"`.
+ */
+interface TextareaProps extends Omit<React.TextareaHTMLAttributes<HTMLTextAreaElement>, "size"> {
+    label?: string;
+    showClear?: boolean;
+    note?: string;
+    error?: string;
+    containerClassName?: string;
+    tooltip?: string;
+    tooltipPosition?: TooltipPosition;
+    maxLength?: number;
+    resize?: "none" | "vertical";
+}
+/**
+ * Multi-line input with label, clear, optional counter from `maxLength`, and note/error rows.
+ *
+ * @param {TextareaProps} props - Native `textarea` props plus H2O chrome.
+ * @param {React.Ref<HTMLTextAreaElement>} ref - Forwarded to `<textarea>`.
+ * @returns {React.ReactElement} Labeled field wrapper and counter when applicable.
+ */
+export declare const Textarea: React.ForwardRefExoticComponent<TextareaProps & React.RefAttributes<HTMLTextAreaElement>>;
+export {};

package/dist/charts/components/src/time-picker/time-picker.d.ts

@@ -0,0 +1,31 @@
+import "./time-picker.css";
+/**
+ * Time selection UI: one clock or a start/end **range**; hour/minute columns with optional 12h format.
+ *
+ * @property {"single"|"range"} [mode] - `single` uses `value` as `string | null`; `range` as `[string|null, string|null]`. Default `"single"`.
+ * @property {string|null|[string|null,string|null]} [value] - `"HH:MM"`, partial `"HH:"` while picking hour, or `null` for empty. Range: tuple of same.
+ * @property {(v: string|null|[string|null,string|null]) => void} [onChange] - Emits the same shapes as `value` as the user picks.
+ * @property {12|24} [hourFormat] - 12- or 24-hour labels. Default `24`.
+ * @property {number} [minuteStep] - Minutes grid step, e.g. `5` → `00,05,…,55`. Default `5`.
+ */
+interface TimePickerProps {
+    mode?: "single" | "range";
+    value?: string | null | [string | null, string | null];
+    onChange?: (value: string | null | [string | null, string | null]) => void;
+    hourFormat?: 12 | 24;
+    minuteStep?: number;
+    startLabel?: string;
+    endLabel?: string;
+    disabled?: boolean;
+    className?: string;
+    error?: string;
+    note?: string;
+}
+/**
+ * Picker for a time or time range, with hour/minute dropdowns and optional labels or validation chrome.
+ *
+ * @param {TimePickerProps} props - Mode, `value`/`onChange` shape, and `hourFormat` / `minuteStep`.
+ * @returns {JSX.Element} The field group(s) and time lists when open.
+ */
+export declare const TimePicker: ({ mode, value, onChange, hourFormat, minuteStep, startLabel, endLabel, disabled, className, error, note, }: TimePickerProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/charts/components/src/toast/toast.d.ts

@@ -0,0 +1,54 @@
+import "./toast.css";
+import type React from "react";
+/**
+ * Color/semantic key for a toast: maps to icon and ARIA `role` (`error`/`warning` → `alert`, others often `status`).
+ * @type {("info"|"error"|"warning"|"success")}
+ */
+export type ToastVariant = "info" | "error" | "warning" | "success";
+/**
+ * Viewport region where `ToastProvider` positions the toast container (CSS BEM variant).
+ * @type {("top-right"|"top-left"|"bottom-right"|"bottom-left"|"top-center"|"bottom-center")}
+ */
+export type ToastPosition = "top-right" | "top-left" | "bottom-right" | "bottom-left" | "top-center" | "bottom-center";
+interface ToastAction {
+    label: string;
+    action: () => void;
+}
+/**
+ * Options passed to `useToast().show(options)`; describes one transient notification.
+ *
+ * @property {ToastVariant} variant - Visual/semantic style.
+ * @property {string} title - Bold heading in the toast header.
+ * @property {string} [description] - Optional body copy under the title.
+ * @property {ToastAction} [primaryAction] - Primary CTA; presence disables auto-dismiss by default.
+ * @property {ToastAction} [secondaryAction] - Secondary CTA; same as primary for auto-dismiss rules.
+ * @property {number} [duration] - Auto-close delay in ms. Default `5000`; `0` disables (`primaryAction` / `secondaryAction` also keep it open without timer).
+ */
+export interface ToastOptions {
+    variant: ToastVariant;
+    title: string;
+    description?: string;
+    primaryAction?: ToastAction;
+    secondaryAction?: ToastAction;
+    duration?: number;
+}
+/**
+ * Props for `ToastProvider` — mount once near the app root to enable `useToast()`.
+ *
+ * @property {React.ReactNode} children - Your app; context is available to descendants.
+ * @property {ToastPosition} [position] - Viewport region for the stack. Default `"bottom-right"`.
+ * @property {number} [maxToasts] - Max simultaneous toasts; older may be evicted. Default `5`.
+ */
+interface ToastProviderProps {
+    children: React.ReactNode;
+    position?: ToastPosition;
+    maxToasts?: number;
+}
+/**
+ * Context provider: renders `children` and a fixed-position stack of toasts; wires timers and `maxToasts` cap.
+ *
+ * @param {object} props - `position`, `maxToasts`, and `children`.
+ * @returns {JSX.Element} Provider element plus the global toast region.
+ */
+export declare const ToastProvider: React.FC<ToastProviderProps>;
+export {};