@skygraph/react 0.0.0-placeholder.0 → 0.4.0

package/dist/index.d.ts

@@ -0,0 +1,3671 @@
+import { a as SizeType, B as BaseComponentProps, S as SizableProps, I as InteractiveProps } from './common-CdpocIEz.js';
+import { i as SgLocale, j as PrintOptions, k as CalendarLocale, l as PrintableProp, m as SlotClassNames, n as SlotStyles } from './Table-IvijKCyd.js';
+export { A as AggregateType, B as BreadcrumbLocale, o as CarouselLocale, p as CascaderLocale, C as CellSpan, q as ChartsLocale, D as DashboardLocale, r as DatePickerLocale, s as DrawerLocale, t as EmptyLocale, E as ExpandableConfig, F as FilterDropdownProps, a as FlatRow, v as FormLocale, w as GanttLocale, G as GroupRow, H as HeaderCell, I as InlineEditLocale, x as InputPasswordLocale, M as ModalLocale, N as NotificationLocale, y as PaginationLocale, P as PinnedRowsConfig, z as PopconfirmLocale, J as RateLocale, K as ResourceCalendarLocale, R as RowNumberConfig, b as RowSelectionConfig, L as SchemaFormEditorLocale, O as SearchInputLocale, S as SelectionSummaryAction, Q as SkeletonLocale, V as SpinLocale, c as SummaryCell, T as Table, d as TableColumn, e as TableLocale, f as TableProps, W as TableRef, X as TagInputLocale, Y as TagLocale, Z as TimelineLocale, _ as TransferLocale, g as TreeConfig, $ as TreeSelectLocale, a0 as UploadLocale, U as UseTableOptions, h as UseTableReturn, u as useTable } from './Table-IvijKCyd.js';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as React$1 from 'react';
+import React__default, { ReactNode, CSSProperties, MouseEvent } from 'react';
+import { FieldType, AutoFieldOption, JSONSchema } from './form.js';
+export { AutoField, AutoFieldConfig, AutoFieldProps, Field, FieldProps, Form, FormContext, FormList, FormListProps, FormProps, FormProvider, FormProviderProps, JSONSchemaProperty, SchemaForm, SchemaFormProps, SubmitButton, SubmitButtonProps, UseFieldArrayReturn, UseFieldReturn, UseFormOptions, UseFormReturn, ZodAdapterOptions, ZodLikeSchema, ZodObjectLikeSchema, jsonSchemaToDefaults, jsonSchemaToFields, jsonSchemaToRules, useField, useFieldArray, useForm, useFormContext, useFormProvider, useWatch, zodDefaults, zodRule, zodRules, zodToJsonSchema } from './form.js';
+import { Core, GraphEngineOptions, GraphEngine, GraphState, GraphNode, GraphEdge, NodeId, CalendarAvailabilityRule, CalendarScale, CalendarConflict } from '@skygraph/core';
+export { CalendarAvailabilityRule as AvailabilityRule, CalendarScale, ColumnFilter, CalendarConflict as Conflict, FilterFn, MeasureCache, MeasureCacheEvent, MeasureCacheListener, RowId, SortConfig, SortDirection, TreeFieldNames, TreeKey, TreeNodeData, VirtualEngine, VirtualEngineEvent, VirtualEngineListener, VirtualEngineOptions, VirtualItem, VirtualRange, createMeasureCache, createVirtual } from '@skygraph/core';
+export { CheckInfo, DragInfo, DropInfo, EditInfo, ExpandInfo, SelectInfo, Tree, TreeLocale, TreeNodeAction, TreeNodeStatus, TreeProps, TreeSelect, TreeSelectProps, UseTreeOptions, UseTreeReturn, useTree } from './tree.js';
+export { UseVirtualScrollOptions, UseVirtualScrollReturn, VirtualList, VirtualListProps, VirtualListRef, useVirtualScroll } from './virtual.js';
+export { HistoryPanel, HistoryPanelProps, UseHistoryReturn, useHistory } from './devtools.js';
+export { C as CellEditorProps, a as CellPosition, b as CellRange, c as CellValue, D as DataGrid, d as DataGridColumn, e as DataGridContextMenuItem, f as DataGridLocale, g as DataGridProps, h as DataGridRef, i as DataGridSummaryRow } from './datagrid-B6hg5yJh.js';
+
+/**
+ * Global Skygraph component configuration merged through React context.
+ *
+ * По `prefixCls`: сознательно НЕ входит в публичный API до реализации
+ * (вариант A в `docs/styling-plan.md`, фаза 4). На практике все корневые классы
+ * имеют стабильный префикс `.sg-*`; если нужна изоляция — используйте изолированный
+ * скоуп на хосте (шадоу-рут/отдельный контейнер со своими токенами).
+ */
+interface SgConfig {
+    /** Default size token for nested components. */
+    size?: SizeType;
+    /** Disables interactions for nested components when true. */
+    disabled?: boolean;
+    /** Enables bordered styling for nested components when true. */
+    bordered?: boolean;
+    /** Locale messages shallow-merged with the parent provider when set. */
+    locale?: SgLocale;
+}
+/** Props for `ConfigProvider`, extending `SgConfig` with React children. */
+interface ConfigProviderProps extends SgConfig {
+    /** Tree of components that consume merged configuration from this provider. */
+    children: React__default.ReactNode;
+}
+/**
+ * Merges Skygraph configuration with any parent provider and exposes it via context.
+ * Descendants read values through `useConfig` or `useConfigWithDefaults`.
+ */
+declare function ConfigProvider({ children, ...config }: ConfigProviderProps): react_jsx_runtime.JSX.Element;
+/** Returns the merged `SgConfig` from the nearest ancestor `ConfigProvider`. */
+declare function useConfig(): SgConfig;
+
+/**
+ * English (US) locale preset for {@link ConfigProvider}.
+ *
+ * Covers the strings consumed by all React-adapter components: hidden
+ * helper aria-labels, button tooltips, placeholders, modal/drawer/notification
+ * close buttons, chart aria roles, date-picker / calendar navigation,
+ * dashboard / gantt / resource-calendar / timeline accessibility names,
+ * and schema-form-editor toolbar.
+ */
+declare const en_US: SgLocale;
+
+/**
+ * Russian (RU) locale preset for {@link ConfigProvider}.
+ */
+declare const ru_RU: SgLocale;
+
+/**
+ * Chinese (Simplified, zh-CN) locale preset for {@link ConfigProvider}.
+ *
+ * Mirrors the structure of {@link en_US}; values translated for general
+ * UI use. Identifiers, `sg-*` class names and unicode glyphs are not
+ * translated (see CHARTER §10).
+ */
+declare const zh_CN: SgLocale;
+
+/**
+ * German (de-DE) locale preset for {@link ConfigProvider}.
+ *
+ * Mirrors the structure of {@link en_US}; values translated for general
+ * UI use. Identifiers, `sg-*` class names and unicode glyphs are not
+ * translated (see CHARTER §10).
+ */
+declare const de_DE: SgLocale;
+
+/**
+ * French (fr-FR) locale preset for {@link ConfigProvider}.
+ *
+ * Mirrors the structure of {@link en_US}; values translated for general
+ * UI use. Identifiers, `sg-*` class names and unicode glyphs are not
+ * translated (see CHARTER §10).
+ */
+declare const fr_FR: SgLocale;
+
+/**
+ * Spanish (es-ES) locale preset for {@link ConfigProvider}.
+ *
+ * Mirrors the structure of {@link en_US}; values translated for general
+ * UI use. Identifiers, `sg-*` class names and unicode glyphs are not
+ * translated (see CHARTER §10).
+ */
+declare const es_ES: SgLocale;
+
+declare function useComputed(core: Core, path: string): unknown;
+
+/**
+ * Вычисляет CSS `@page` блок для popup-страницы по `PrintOptions`. Вынесено
+ * в отдельную функцию ради тестируемости (snapshot-тест без `window.open`).
+ */
+declare function buildPageRule(opts?: PrintOptions): string;
+/**
+ * Собирает HTML-документ popup-страницы. Используется `printElement` и
+ * напрямую тестами — поэтому никаких `window.*` побочных эффектов.
+ *
+ * Стратегия:
+ *  1. Клонируем `<style>` и `<link rel="stylesheet">` из текущего
+ *     документа, чтобы popup увидел SkyGraph-стили (включая `print.css`).
+ *  2. Дописываем нашу `@page`-секцию + `body` reset.
+ *  3. Опциональный `transform: scale(...)` на обёртке.
+ *  4. Подставляем `outerHTML` исходного `node`.
+ *  5. Триггерим `print()` после `load`-события, чтобы шрифты и стили
+ *     успели приехать в popup.
+ */
+declare function buildPrintHtml(fragment: string, opts?: PrintOptions, documentRef?: Document | null): string;
+/**
+ * Открывает popup-окно, инжектирует SkyGraph-стили + `outerHTML` `node`-а,
+ * и вызывает `window.print()`. Возвращает popup-окно или `null`, если
+ * браузер заблокировал открытие нового окна.
+ *
+ * Пример:
+ * ```ts
+ * const ref = useRef<HTMLDivElement>(null)
+ * <button onClick={() => printElement(ref.current, { fileName: 'report.pdf' })}>
+ *   Print
+ * </button>
+ * ```
+ *
+ * Никаких runtime-зависимостей: всё на штатном `window.open` + CSS
+ * `@media print`. PDF получается через системный диалог печати → "Save as PDF".
+ */
+declare function printElement(node: Element | null, opts?: PrintOptions): Window | null;
+
+/** One node in a cascader tree; children define the next column. */
+interface CascaderOption {
+    /** Stable value included in the selected path. */
+    value: string | number;
+    /** Display node for the option row. */
+    label: React__default.ReactNode;
+    /** Nested options for the next level. */
+    children?: CascaderOption[];
+    /** When `true`, the option cannot be chosen. */
+    disabled?: boolean;
+    /** When `false`, children may load asynchronously (see `loadData`). */
+    isLeaf?: boolean;
+}
+/** Props for hierarchical single- or multi-select with search and async children. */
+interface CascaderProps {
+    /** Top-level options; each may nest `children`. */
+    options: CascaderOption[];
+    /** Selected path from root to current value (controlled). */
+    value?: (string | number)[];
+    /** Initial path when uncontrolled. */
+    defaultValue?: (string | number)[];
+    /** Fired with the value path and resolved option chain. */
+    onChange?: (value: (string | number)[], selectedOptions: CascaderOption[]) => void;
+    /**
+     * Shown when nothing is selected.
+     * @default 'Please select'
+     */
+    placeholder?: string;
+    /**
+     * Shows a clear control when there is a selection.
+     * @default false
+     */
+    allowClear?: boolean;
+    /**
+     * Disables opening and changing the value.
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * Visual size of the trigger.
+     * @default 'middle'
+     */
+    size?: 'small' | 'middle' | 'large';
+    /**
+     * Allows several leaf paths as tags.
+     * @default false
+     */
+    multiple?: boolean;
+    /**
+     * Enables search, or `{ filter }` for custom path matching.
+     * @default false
+     */
+    showSearch?: boolean | {
+        filter?: (inputValue: string, path: CascaderOption[]) => boolean;
+    };
+    /**
+     * Opens the next column on click or hover.
+     * @default 'click'
+     */
+    expandTrigger?: 'click' | 'hover';
+    /**
+     * Commits selection on non-leaf nodes when `true`.
+     * @default false
+     */
+    changeOnSelect?: boolean;
+    /** Custom display for the single-select trigger from labels and options. */
+    displayRender?: (labels: string[], selectedOptions: CascaderOption[]) => React__default.ReactNode;
+    /** Loads children for a node when `isLeaf` is false and children are empty. */
+    loadData?: (selectedOptions: CascaderOption[]) => void;
+    /** Max tags shown in multiple mode before a “+N” summary. */
+    maxTagCount?: number;
+    /** Inline styles for the dropdown panel. */
+    dropdownStyle?: React__default.CSSProperties;
+    /** Root wrapper class name. */
+    className?: string;
+    /** Root wrapper inline styles. */
+    style?: React__default.CSSProperties;
+    /** Renders minimal markup without cascader CSS classes. */
+    unstyled?: boolean;
+}
+
+/**
+ * Hierarchical picker with columns, optional multi-select, search, and lazy-loaded branches.
+ */
+declare function Cascader(props: CascaderProps): react_jsx_runtime.JSX.Element;
+
+/** Values passed to `headerRender` for custom calendar chrome. */
+interface CalendarHeaderInfo {
+    /** Date currently shown in the panel (year/month context). */
+    value: Date;
+    /** Whether the panel shows the month grid or year/month picker. */
+    type: 'month' | 'year';
+    /** Updates the panel date (e.g. month/year selects). */
+    onChange: (date: Date) => void;
+    /** Switches between month and year panel modes. */
+    onTypeChange: (type: 'month' | 'year') => void;
+}
+/** Context for `cellRender` describing which cell kind is being rendered. */
+interface CalendarCellInfo {
+    /** `date` for day cells, `month` for month tiles in year view. */
+    type: 'date' | 'month';
+}
+/** Calendar event marker for a specific date. */
+interface CalendarEvent {
+    /** Date of the event. */
+    date: Date;
+    /** Short label shown in the cell. */
+    title: string;
+    /** Color dot or badge color. */
+    color?: string;
+    /** Unique key. */
+    key?: string;
+}
+/** Props for the month/year calendar with optional custom header and cells. */
+interface CalendarProps {
+    /** Controlled selected date. */
+    value?: Date;
+    /** Initial selected date when uncontrolled. */
+    defaultValue?: Date;
+    /** Fired when the selected date changes. */
+    onChange?: (date: Date) => void;
+    /** Fired when the visible panel date or view mode changes. */
+    onPanelChange?: (date: Date, mode: 'month' | 'year') => void;
+    /** Fired when a date is chosen (including month pick in year view). */
+    onSelect?: (date: Date) => void;
+    /** Controlled panel mode: month grid or year/month list. */
+    mode?: 'month' | 'year';
+    /**
+     * Uses full layout including footer "today" when `true`.
+     * @default true
+     */
+    fullscreen?: boolean;
+    /** Custom header UI; receives navigation state and handlers. */
+    headerRender?: (info: CalendarHeaderInfo) => React__default.ReactNode;
+    /** Extra content inside day or month cells. */
+    cellRender?: (date: Date, info: CalendarCellInfo) => React__default.ReactNode;
+    /** Marks dates non-interactive when it returns `true`. */
+    disabledDate?: (date: Date) => boolean;
+    /** Overrides default English month/day names and today label. */
+    locale?: CalendarLocale;
+    /** Root element class name. */
+    className?: string;
+    /** Root element inline styles. */
+    style?: React__default.CSSProperties;
+    /** Renders semantic structure without Skygraph calendar CSS. */
+    unstyled?: boolean;
+    /** Shows ISO week numbers on the left of each row. */
+    showWeekNumber?: boolean;
+    /** First day of week: 0=Sunday, 1=Monday, etc. @default 0 */
+    weekStartDay?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+    /** Enables range selection mode. */
+    rangeSelection?: boolean;
+    /** Controlled range value [start, end]. */
+    rangeValue?: [Date | null, Date | null];
+    /** Default range when uncontrolled. */
+    defaultRangeValue?: [Date | null, Date | null];
+    /** Fired when range changes. */
+    onRangeChange?: (range: [Date | null, Date | null]) => void;
+    /** Enables multiple date selection mode. */
+    multipleSelection?: boolean;
+    /** Controlled array of selected dates. */
+    multipleValue?: Date[];
+    /** Default multiple selected dates. */
+    defaultMultipleValue?: Date[];
+    /** Fired when multiple selection changes. */
+    onMultipleChange?: (dates: Date[]) => void;
+    /** Event markers per date. */
+    events?: CalendarEvent[];
+    /** Max events to show per cell before "+N more". @default 3 */
+    maxEvents?: number;
+    /** Enables keyboard navigation. @default true */
+    keyboard?: boolean;
+}
+
+/**
+ * Month/year calendar with panel navigation, week numbers, range/multi selection,
+ * event markers, keyboard navigation, and fullscreen or compact layout.
+ */
+declare function Calendar(props: CalendarProps): react_jsx_runtime.JSX.Element;
+
+/** Props for loading spinner, overlay, and optional content blur. */
+interface SpinProps extends BaseComponentProps, SizableProps {
+    /** When `true`, shows the loading state (subject to `delay`). @default true */
+    spinning?: boolean;
+    /** Milliseconds to wait before showing the spinner after `spinning` becomes true. */
+    delay?: number;
+    /** Optional text below the indicator. */
+    tip?: string;
+    /** When `true`, covers the viewport instead of inline or wrapping children. */
+    fullscreen?: boolean;
+    /** Custom spinner node; defaults to a styled status element. */
+    indicator?: React__default.ReactNode;
+    /** When set, shows an overlay with blur on this content while loading. */
+    children?: React__default.ReactNode;
+}
+/**
+ * Loading indicator with optional delay, tip, fullscreen mode, and child overlay.
+ */
+declare function Spin({ spinning, size: sizeProp, delay, tip, fullscreen, indicator, children, className, style, unstyled, }: SpinProps): react_jsx_runtime.JSX.Element | null;
+
+/** Props for the Button component. */
+interface ButtonProps extends BaseComponentProps, InteractiveProps, SizableProps {
+    /** Visual style variant. @default 'default' */
+    type?: 'default' | 'primary' | 'dashed' | 'text' | 'link';
+    /** Native HTML button type attribute. @default 'button' */
+    htmlType?: 'button' | 'submit' | 'reset';
+    /**
+     * Visually flags a destructive action. Combines with `type` (e.g. a
+     * `danger` `primary` button is solid red, a `danger` `text` is red text).
+     * Adds the `sg-button-danger` modifier class.
+     * @default false
+     */
+    danger?: boolean;
+    /** Stretches the button to fill its parent container. @default false */
+    block?: boolean;
+    /** Click event handler. */
+    onClick?: (e: React__default.MouseEvent<HTMLButtonElement>) => void;
+    /** Button content. */
+    children?: React__default.ReactNode;
+}
+/** General-purpose button with multiple visual variants, sizes, and loading state. */
+declare function Button({ type, size: sizeProp, disabled: disabledProp, loading, htmlType, danger, block, onClick, children, className, style, unstyled, }: ButtonProps): react_jsx_runtime.JSX.Element;
+
+/** Props for the Input component. */
+interface InputProps extends BaseComponentProps, InteractiveProps, SizableProps {
+    /** Controlled input value. */
+    value?: string;
+    /** Uncontrolled initial value. */
+    defaultValue?: string;
+    /** Placeholder text when the field is empty. */
+    placeholder?: string;
+    /** Native HTML input type. @default 'text' */
+    type?: 'text' | 'email' | 'password' | 'number';
+    /**
+     * Marks the field as read-only. The value is selectable and submitted
+     * but cannot be edited. Sets the HTML `readonly` attribute,
+     * `aria-readonly="true"`, and adds the `sg-input-readonly` modifier class.
+     * @default false
+     */
+    readOnly?: boolean;
+    /** DOM id forwarded to the underlying `<input>`. */
+    id?: string;
+    /** Exposes invalid state to assistive technologies. */
+    'aria-invalid'?: boolean | 'false' | 'true' | 'grammar' | 'spelling';
+    /** Marks the field as required for assistive technologies. */
+    'aria-required'?: boolean | 'false' | 'true';
+    /** Connects the input to description / error nodes for assistive technologies. */
+    'aria-describedby'?: string;
+    /** Called when the text value changes. */
+    onChange?: (value: string) => void;
+    /** Called when the input loses focus. */
+    onBlur?: () => void;
+    /** Called when the input gains focus. */
+    onFocus?: () => void;
+}
+/** Single-line text input with optional loading indicator and configurable HTML type. */
+declare function Input({ value, defaultValue, placeholder, type, readOnly, size: sizeProp, disabled: disabledProp, loading, onChange, onBlur, onFocus, 'aria-invalid': ariaInvalid, 'aria-required': ariaRequired, 'aria-describedby': ariaDescribedBy, id, className, style, unstyled, }: InputProps): react_jsx_runtime.JSX.Element;
+
+/** Props for the modal dialog overlay. */
+interface ModalProps extends BaseComponentProps {
+    /** When `true`, the modal is visible. */
+    open: boolean;
+    /** Called when the modal should close (Escape, mask click, or close control). */
+    onClose: () => void;
+    /** Optional heading text; used for the accessible name when set. */
+    title?: string;
+    /** Main dialog body content. */
+    children?: React__default.ReactNode;
+    /**
+     * Footer region below the body. Omit to render the default OK / Cancel pair
+     * (enabled when `onOk` is provided). Pass `null` to hide the footer entirely.
+     */
+    footer?: React__default.ReactNode;
+    /** Dialog width as a CSS length or number (pixels). @default 520 */
+    width?: number | string;
+    /** Called when the default OK button is clicked. Enables the default footer. */
+    onOk?: () => void | Promise<void>;
+    /** Label for the default OK button. Falls back to `locale.modal.okText` → `OK`. */
+    okText?: string;
+    /** Label for the default Cancel button. Falls back to `locale.modal.cancelText` → `Cancel`. */
+    cancelText?: string;
+    /** Visual type of the default OK button. @default 'primary' */
+    okType?: 'primary' | 'default' | 'dashed' | 'text';
+    /** Shows the OK button in loading state and disables interactions. */
+    confirmLoading?: boolean;
+}
+/**
+ * Modal dialog with mask, optional title/footer, focus trap, and Escape to close.
+ * Renders a bare structure when `unstyled` is set.
+ */
+declare function Modal({ open, onClose, title, children, footer, width, onOk, okText: okTextProp, cancelText: cancelTextProp, okType, confirmLoading, className, unstyled, }: ModalProps): react_jsx_runtime.JSX.Element | null;
+
+/** Props for the Checkbox component. */
+interface CheckboxProps extends BaseComponentProps, InteractiveProps {
+    /** Controlled checked state. */
+    checked?: boolean;
+    /** Uncontrolled initial checked state. */
+    defaultChecked?: boolean;
+    /** Renders the native checkbox in indeterminate state. */
+    indeterminate?: boolean;
+    /** Called when the checked state changes. */
+    onChange?: (checked: boolean) => void;
+    /** Label content beside the control. */
+    children?: React__default.ReactNode;
+}
+/** Labeled checkbox with indeterminate support and optional loading state. */
+declare function Checkbox({ checked, defaultChecked, disabled: disabledProp, loading, indeterminate, onChange, children, className, style, unstyled, }: CheckboxProps): react_jsx_runtime.JSX.Element;
+
+/** One selectable option in a radio group. */
+interface RadioOption {
+    /** Visible label for the option. */
+    label: string;
+    /** Value emitted when this option is selected. */
+    value: string | number;
+    /** Disables this option regardless of group-level disabled state. */
+    disabled?: boolean;
+}
+/** Props for the RadioGroup component. */
+interface RadioGroupProps extends BaseComponentProps, InteractiveProps {
+    /** Controlled selected value. */
+    value?: string | number;
+    /** Uncontrolled initial selected value. */
+    defaultValue?: string | number;
+    /** Options rendered as radio controls. */
+    options: RadioOption[];
+    /** Stacks options horizontally or vertically. @default 'horizontal' */
+    direction?: 'horizontal' | 'vertical';
+    /** Called when the selected value changes. */
+    onChange?: (value: string | number) => void;
+}
+/** Mutually exclusive radio options in a horizontal or vertical group. */
+declare function RadioGroup({ value, defaultValue, options, direction, disabled: disabledProp, loading, onChange, className, style, unstyled, }: RadioGroupProps): react_jsx_runtime.JSX.Element;
+
+/** Props for the Switch component. */
+interface SwitchProps extends BaseComponentProps, InteractiveProps, SizableProps {
+    /** Controlled on state. */
+    checked?: boolean;
+    /** Uncontrolled initial on state. */
+    defaultChecked?: boolean;
+    /** Called when the switch is toggled. */
+    onChange?: (checked: boolean) => void;
+    /** Content shown while the switch is on. */
+    checkedChildren?: React__default.ReactNode;
+    /** Content shown while the switch is off. */
+    unCheckedChildren?: React__default.ReactNode;
+}
+/** Toggle switch with optional on/off slot content and loading state. */
+declare function Switch({ checked, defaultChecked, disabled: disabledProp, loading, size: sizeProp, onChange, checkedChildren, unCheckedChildren, className, style, unstyled, }: SwitchProps): react_jsx_runtime.JSX.Element;
+
+/** Single selectable entry in a Select dropdown or native option list. */
+interface SelectOption {
+    /** Display text for the option. */
+    label: string;
+    /** Value submitted with the form and returned by onChange. */
+    value: string | number;
+    /** When true, the option cannot be selected. */
+    disabled?: boolean;
+    /** When true, shows a loading state for the option. */
+    loading?: boolean;
+}
+/** Props shared by single and multiple modes. */
+interface SelectPropsBase extends BaseComponentProps, InteractiveProps, SizableProps {
+    /** Options shown in the dropdown or native select. */
+    options: SelectOption[];
+    /** Text shown when nothing is selected. */
+    placeholder?: string;
+    /** Called when the control loses focus. */
+    onBlur?: () => void;
+    /**
+     * Accessible name for the control. Required for the styled (non-`unstyled`)
+     * variant when there is no surrounding `<label htmlFor=...>` — the styled
+     * trigger is a `<div role="combobox">` and a parent `<label>` cannot
+     * associate. WCAG 4.1.2 expects a name for every interactive control;
+     * provide either `'aria-label'` or `'aria-labelledby'`.
+     *
+     * In the `unstyled` variant the underlying native `<select>` is fully
+     * labelable, so this prop is purely informational there.
+     */
+    'aria-label'?: string;
+    /** Id(s) of the element(s) that describe this control. Mirrors `aria-label`. */
+    'aria-labelledby'?: string;
+}
+/** Single-select variant. `value` is one option value. */
+interface SelectPropsSingle extends SelectPropsBase {
+    /** When false/omitted, the component is single-select. */
+    multiple?: false;
+    /** Controlled selected value. */
+    value?: string | number;
+    /** Initial value when uncontrolled. */
+    defaultValue?: string | number;
+    /** Called when the selection changes. */
+    onChange?: (value: string | number) => void;
+}
+/**
+ * Multiple-select variant. `value` is an array. Selecting an option
+ * toggles its presence in the array; the dropdown stays open while picking.
+ */
+interface SelectPropsMultiple extends SelectPropsBase {
+    /** Enables multi-select mode. Render shows chips per selected option. */
+    multiple: true;
+    /** Controlled selected values. */
+    value?: (string | number)[];
+    /** Initial selection when uncontrolled. */
+    defaultValue?: (string | number)[];
+    /** Called when the selection set changes. */
+    onChange?: (values: (string | number)[]) => void;
+}
+/** Props for the Select combobox; supports styled or native unstyled rendering. */
+type SelectProps = SelectPropsSingle | SelectPropsMultiple;
+/**
+ * Dropdown or native select for choosing one option (default) or many
+ * options when `multiple` is set. Keyboard and click-outside behavior apply
+ * in the styled (non-unstyled) mode.
+ *
+ * @default placeholder - `'Select...'`
+ */
+declare function Select(props: SelectProps): react_jsx_runtime.JSX.Element;
+
+/** Configuration for one tab: label, panel content, and optional states. */
+interface TabItem {
+    /** Unique key used for selection and ARIA. */
+    key: string;
+    /** Tab label in the tab list. */
+    label: React__default.ReactNode;
+    /** Panel body shown when this tab is active. */
+    children: React__default.ReactNode;
+    /** When true, the tab cannot be activated. */
+    disabled?: boolean;
+    /** When true, shows a spinner and blocks activation until cleared. */
+    loading?: boolean;
+}
+/** Props for the tab list and associated single visible panel. */
+interface TabsProps extends BaseComponentProps, SizableProps {
+    /**
+     * Visual chrome: `card` — bordered strip with the active tab attached to the
+     * panel (classic desktop tabs). `line` — minimal underline indicator only.
+     * @default 'card'
+     */
+    type?: 'line' | 'card';
+    /** Tab definitions including labels and panel content. */
+    items: TabItem[];
+    /** Controlled active tab key. */
+    activeKey?: string;
+    /** Initial active tab when `activeKey` is not controlled. */
+    defaultActiveKey?: string;
+    /** Called when the active tab changes after user interaction. */
+    onChange?: (key: string) => void;
+}
+/**
+ * Tabbed interface with keyboard navigation between tabs and one visible panel.
+ * Resolves initial active key from props, then first item, when uncontrolled.
+ */
+declare function Tabs({ type: typeProp, items, activeKey, defaultActiveKey, onChange, size: sizeProp, className, style, unstyled, }: TabsProps): react_jsx_runtime.JSX.Element;
+
+/** Props for the Tooltip component. */
+interface TooltipProps extends BaseComponentProps {
+    /** Content shown in the tooltip on hover. */
+    title: React__default.ReactNode;
+    /** Tooltip position relative to the trigger. @default 'top' */
+    placement?: 'top' | 'bottom' | 'left' | 'right';
+    /** Single React element that receives hover / focus handlers as the trigger. */
+    children: React__default.ReactElement;
+}
+/**
+ * Shows floating help text on hover or keyboard focus, with optional placement and fade transition.
+ * The `aria-describedby` link is forwarded to the trigger element so assistive tech reads it on focus.
+ */
+declare function Tooltip({ title, placement, children, className, unstyled, }: TooltipProps): react_jsx_runtime.JSX.Element;
+
+/** Props for the multiline text field with optional character count and loading overlay. */
+interface TextareaProps extends BaseComponentProps, InteractiveProps, SizableProps {
+    /** Controlled value; when omitted, uses internal state seeded by `defaultValue`. */
+    value?: string;
+    /** Initial value when uncontrolled. */
+    defaultValue?: string;
+    /** Placeholder shown when empty. */
+    placeholder?: string;
+    /** Visible row count on the native textarea. @default 4 */
+    rows?: number;
+    /** Hard cap on input length enforced in the change handler. */
+    maxLength?: number;
+    /** Shows current length (and `maxLength` when set) beside the field in styled mode. */
+    showCount?: boolean;
+    /** DOM id forwarded to the underlying `<textarea>`. */
+    id?: string;
+    /** Exposes invalid state to assistive technologies. */
+    'aria-invalid'?: boolean | 'false' | 'true' | 'grammar' | 'spelling';
+    /** Connects the textarea to description / error nodes for assistive technologies. */
+    'aria-describedby'?: string;
+    /** Marks the field as required for assistive technologies. */
+    'aria-required'?: boolean | 'false' | 'true';
+    /** Emits the full string on each change. */
+    onChange?: (value: string) => void;
+    /** Passed through to the textarea blur event. */
+    onBlur?: () => void;
+    /** Passed through to the textarea focus event. */
+    onFocus?: () => void;
+}
+/**
+ * Styled textarea with configurable rows, optional character count, and loading state from shared interactive props.
+ */
+declare function Textarea({ value, defaultValue, placeholder, rows, maxLength, showCount, disabled: disabledProp, loading, size: sizeProp, onChange, onBlur, onFocus, id, 'aria-invalid': ariaInvalid, 'aria-describedby': ariaDescribedBy, 'aria-required': ariaRequired, className, style, unstyled, }: TextareaProps): react_jsx_runtime.JSX.Element;
+
+/** Props for the InputNumber component. */
+interface InputNumberProps extends BaseComponentProps, InteractiveProps, SizableProps {
+    /** Controlled numeric value. */
+    value?: number;
+    /** Uncontrolled initial value. */
+    defaultValue?: number;
+    /** Lower bound applied on change and via stepper. */
+    min?: number;
+    /** Upper bound applied on change and via stepper. */
+    max?: number;
+    /** Amount added or subtracted by the stepper buttons. @default 1 */
+    step?: number;
+    /** Decimal places enforced after clamping. */
+    precision?: number;
+    /** Placeholder when the field has no value. */
+    placeholder?: string;
+    /** Called with the clamped number or null when the field is cleared. */
+    onChange?: (value: number | null) => void;
+    /** Called when the input loses focus. */
+    onBlur?: () => void;
+}
+/** Numeric field with +/- controls, optional bounds, precision, and loading state. */
+declare function InputNumber({ value, defaultValue, min, max, step, precision, disabled: disabledProp, loading, placeholder, size: sizeProp, onChange, onBlur, className, style, unstyled, }: InputNumberProps): react_jsx_runtime.JSX.Element;
+
+type PickerMode = 'date' | 'month' | 'year' | 'week';
+/** Named shortcut that sets the calendar to a single date or a range. */
+interface DatePreset {
+    /** Preset label shown in the sidebar. */
+    label: string;
+    /** Date applied for single picker, or [start, end] for range presets. */
+    value: Date | [Date, Date];
+}
+/** Fine-grained options when time selection is enabled on the date picker. */
+interface ShowTimeConfig {
+    /** Time portion format string (supports HH, mm, ss tokens). */
+    format?: string;
+    /** Step between selectable hours in the time scroller. */
+    hourStep?: number;
+    /** Step between selectable minutes in the time scroller. */
+    minuteStep?: number;
+    /** Step between selectable seconds in the time scroller. */
+    secondStep?: number;
+    /** Initial time used when opening the panel without a selected date. */
+    defaultValue?: Date;
+}
+/** Props for picking a single calendar date (and optional time) with presets and placement. */
+interface DatePickerProps extends BaseComponentProps, InteractiveProps, SizableProps {
+    /** Controlled selected date or null when cleared. */
+    value?: Date | null;
+    /** Initial date when uncontrolled. */
+    defaultValue?: Date;
+    /** Called when the value is committed or cleared; second arg is formatted string. */
+    onChange?: (date: Date | null, dateString: string) => void;
+    /** Called when a day is selected in the calendar (including while picking time). */
+    onCalendarChange?: (date: Date | null) => void;
+    /** Placeholder shown when no date is selected. */
+    placeholder?: string;
+    /** Display and parse format (YYYY, MM, DD, HH, mm, ss). */
+    format?: string;
+    /** Granularity: full date, month only, year only, or week (week mode uses date UI). */
+    picker?: PickerMode;
+    /** When true, show default time UI; when an object, pass ShowTimeConfig. */
+    showTime?: boolean | ShowTimeConfig;
+    /** When true, show a Today action in the footer (date mode without time). */
+    showToday?: boolean;
+    /** When true with showTime, show a Now action in the footer. */
+    showNow?: boolean;
+    /** When true, show a clear control when a value exists. */
+    allowClear?: boolean;
+    /** Return true to disable specific calendar days. */
+    disabledDate?: (date: Date) => boolean;
+    /** Sidebar shortcuts for common dates or ranges. */
+    presets?: DatePreset[];
+    /** Corner alignment of the dropdown relative to the input. */
+    placement?: 'bottomLeft' | 'bottomRight' | 'topLeft' | 'topRight';
+    /** Controlled visibility of the dropdown. */
+    open?: boolean;
+    /** Called when the dropdown opens or closes. */
+    onOpenChange?: (open: boolean) => void;
+    /** Called when the panel closes after an outside click (blur semantics). */
+    onBlur?: () => void;
+    /** When true, the field shows text only; otherwise the input is editable. */
+    inputReadOnly?: boolean;
+}
+/** Props for selecting a start and end date (optional time) in one control. */
+interface RangePickerProps extends BaseComponentProps, InteractiveProps, SizableProps {
+    /** Controlled range; null entries mean that end is not set yet. */
+    value?: [Date | null, Date | null];
+    /** Initial range when uncontrolled. */
+    defaultValue?: [Date, Date];
+    /** Called when the range changes; includes formatted strings for both ends. */
+    onChange?: (dates: [Date | null, Date | null], dateStrings: [string, string]) => void;
+    /** Placeholders for start and end inputs. */
+    placeholder?: [string, string];
+    /** Display format for both values. */
+    format?: string;
+    /** Enable time columns for both ends; object passes ShowTimeConfig. */
+    showTime?: boolean | ShowTimeConfig;
+    /** When true, show a clear control when either end has a value. */
+    allowClear?: boolean;
+    /** Return true to disable specific calendar days. */
+    disabledDate?: (date: Date) => boolean;
+    /** Sidebar shortcuts; tuple values apply as full range, single dates duplicate to range. */
+    presets?: DatePreset[];
+    /** Node between start and end display (default arrow). */
+    separator?: React__default.ReactNode;
+    /** Corner alignment of the range dropdown. */
+    placement?: 'bottomLeft' | 'bottomRight' | 'topLeft' | 'topRight';
+    /** Controlled visibility of the dropdown. */
+    open?: boolean;
+    /** Called when the dropdown opens or closes. */
+    onOpenChange?: (open: boolean) => void;
+}
+/**
+ * Single-date (or month/year) picker with optional time, presets, and typed input.
+ * Dropdown placement, open state, and today/now actions are configurable.
+ *
+ * @default placeholder - `'Select date'`
+ * @default picker - `'date'`
+ * @default showTime - `false`
+ * @default showToday - `true`
+ * @default showNow - `false`
+ * @default allowClear - `true`
+ * @default placement - `'bottomLeft'`
+ * @default inputReadOnly - `false`
+ */
+declare function DatePicker({ value, defaultValue, onChange, onCalendarChange, placeholder, format: formatProp, picker, showTime, showToday, showNow, allowClear, disabledDate, presets, disabled: disabledProp, loading, size: sizeProp, placement, open: openProp, onOpenChange, onBlur, inputReadOnly, className, style, unstyled, }: DatePickerProps): react_jsx_runtime.JSX.Element;
+/**
+ * Two-month range selector with optional time columns and preset shortcuts.
+ * Commits the range after the second date is chosen (or OK when time is enabled).
+ *
+ * @default placeholder - `['Start date', 'End date']`
+ * @default showTime - `false`
+ * @default allowClear - `true`
+ * @default separator - `'→'`
+ * @default placement - `'bottomLeft'`
+ */
+declare function RangePicker({ value, defaultValue, onChange, placeholder, format: formatProp, showTime, allowClear, disabledDate, presets, separator, disabled: disabledProp, loading, size: sizeProp, placement, open: openProp, onOpenChange, className, style, unstyled, }: RangePickerProps): react_jsx_runtime.JSX.Element;
+
+/** Props for a single time value picked via scroll columns and optional Now/Clear. */
+interface TimePickerProps extends BaseComponentProps, InteractiveProps, SizableProps {
+    /** Controlled time string matching the active format. */
+    value?: string;
+    /** Initial time when uncontrolled. */
+    defaultValue?: string;
+    /** Placeholder when the value is empty. */
+    placeholder?: string;
+    /** Display format (HH/hh, mm, ss, A for 12h). */
+    format?: string;
+    /** When true, use 12-hour clock with AM/PM column. */
+    use12Hours?: boolean;
+    /** Step between hour values in the scroller. */
+    hourStep?: number;
+    /** Step between minute values in the scroller. */
+    minuteStep?: number;
+    /** Step between second values in the scroller. */
+    secondStep?: number;
+    /** When true, show the seconds column. */
+    showSecond?: boolean;
+    /** When true, show a Now button that sets current time and closes. */
+    showNow?: boolean;
+    /** When true, show a clear control when a value exists. */
+    allowClear?: boolean;
+    /** Hour values to disable in the hour column. */
+    disabledHours?: () => number[];
+    /** Minute values to disable for the given hour. */
+    disabledMinutes?: (hour: number) => number[];
+    /** Second values to disable for the given hour and minute. */
+    disabledSeconds?: (hour: number, minute: number) => number[];
+    /** Called when the time string changes. */
+    onChange?: (timeString: string) => void;
+    /** Called when the dropdown opens or closes. */
+    onOpenChange?: (open: boolean) => void;
+    /** Controlled visibility of the dropdown. */
+    open?: boolean;
+    /** Reserved for read-only input behavior (currently unused in markup). */
+    inputReadOnly?: boolean;
+    /**
+     * Accessible name for the `role="combobox"` trigger. Wrapping the styled
+     * trigger in a `<label>` does not associate (the trigger is not a form
+     * element), so `aria-label` / `aria-labelledby` is the supported way to
+     * give the control a name. Required for axe `aria-input-field-name`.
+     */
+    'aria-label'?: string;
+    /** Id(s) of the element(s) that label the trigger. Mirrors `aria-label`. */
+    'aria-labelledby'?: string;
+}
+/** Props for two side-by-side TimePicker panels as a start/end range. */
+interface TimeRangePickerProps extends BaseComponentProps, InteractiveProps, SizableProps {
+    /** Controlled start and end time strings. */
+    value?: [string, string];
+    /** Initial range when uncontrolled. */
+    defaultValue?: [string, string];
+    /** Placeholders for start and end fields. */
+    placeholder?: [string, string];
+    /** Shared display format for both pickers. */
+    format?: string;
+    /** When true, both panels use 12-hour mode. */
+    use12Hours?: boolean;
+    /** Shared hour step for both panels. */
+    hourStep?: number;
+    /** Shared minute step for both panels. */
+    minuteStep?: number;
+    /** Shared second step for both panels. */
+    secondStep?: number;
+    /** When true, show seconds on both panels. */
+    showSecond?: boolean;
+    /** When true, show a clear control when either side has a value. */
+    allowClear?: boolean;
+    /** Node between start and end labels. */
+    separator?: React__default.ReactNode;
+    /** Called when either start or end time changes. */
+    onChange?: (timeStrings: [string, string]) => void;
+    /** Called when the combined dropdown opens or closes. */
+    onOpenChange?: (open: boolean) => void;
+    /** Controlled visibility of the range dropdown. */
+    open?: boolean;
+}
+/**
+ * Scroll-column time picker with optional 12h mode, disabled slots, and Now/Clear.
+ * Value is a formatted string; format defaults from use12Hours and showSecond.
+ *
+ * @default placeholder - `'Select time'`
+ * @default use12Hours - `false`
+ * @default hourStep - `1`
+ * @default minuteStep - `1`
+ * @default secondStep - `1`
+ * @default showSecond - `true`
+ * @default showNow - `true`
+ * @default allowClear - `true`
+ * @default inputReadOnly - `false`
+ */
+declare function TimePicker({ value, defaultValue, placeholder, format: formatProp, use12Hours, hourStep, minuteStep, secondStep, showSecond, showNow, allowClear, disabledHours, disabledMinutes, disabledSeconds, disabled: disabledProp, loading, size: sizeProp, onChange, onOpenChange, open: openProp, inputReadOnly: _inputReadOnly, className, style, unstyled, 'aria-label': ariaLabel, 'aria-labelledby': ariaLabelledBy, }: TimePickerProps): react_jsx_runtime.JSX.Element;
+/**
+ * Range control hosting two TimePicker instances for independent start and end times.
+ * Shares format, steps, and 12h setting; inner panels stay open while the range is open.
+ *
+ * @default placeholder - `['Start', 'End']`
+ * @default use12Hours - `false`
+ * @default hourStep - `1`
+ * @default minuteStep - `1`
+ * @default secondStep - `1`
+ * @default showSecond - `true`
+ * @default allowClear - `true`
+ * @default separator - `'→'`
+ */
+declare function TimeRangePicker({ value, defaultValue, placeholder, format: formatProp, use12Hours, hourStep, minuteStep, secondStep, showSecond, allowClear, separator, disabled: disabledProp, loading, size: sizeProp, onChange, onOpenChange, open: openProp, className, style, unstyled, }: TimeRangePickerProps): react_jsx_runtime.JSX.Element;
+
+/** Suggestion row shown in the AutoComplete dropdown. */
+interface AutoCompleteOption {
+    /** Text shown in the list; also used for client-side filtering. */
+    label: string;
+    /** Value written to the input when the row is chosen. */
+    value: string;
+}
+/** Props for text input with filtered suggestions and optional callbacks. */
+interface AutoCompleteProps extends BaseComponentProps, InteractiveProps, SizableProps {
+    /** Controlled input value. */
+    value?: string;
+    /** Initial value when uncontrolled. */
+    defaultValue?: string;
+    /** Suggestion list; filtered by label against current input. */
+    options: AutoCompleteOption[];
+    /** Input placeholder text. */
+    placeholder?: string;
+    /** Called when the typed value changes. */
+    onChange?: (value: string) => void;
+    /** Called on each change with the current query string. */
+    onSearch?: (query: string) => void;
+    /** Called when a suggestion is picked from the list. */
+    onSelect?: (value: string, option: AutoCompleteOption) => void;
+    /** Called when the input loses focus. */
+    onBlur?: () => void;
+}
+/**
+ * Text field with a dropdown of options filtered as the user types.
+ * Opens the list on focus and filters by option label (case-insensitive).
+ */
+declare function AutoComplete({ value, defaultValue, options, placeholder, disabled: disabledProp, loading, size: sizeProp, onChange, onSearch, onSelect, onBlur, className, style, unstyled, }: AutoCompleteProps): react_jsx_runtime.JSX.Element;
+
+/** Props for the Slider component. */
+interface SliderProps extends BaseComponentProps, InteractiveProps {
+    /** Controlled value within min and max. */
+    value?: number;
+    /** Uncontrolled initial value. @default 0 */
+    defaultValue?: number;
+    /** Minimum selectable value. @default 0 */
+    min?: number;
+    /** Maximum selectable value. @default 100 */
+    max?: number;
+    /** Increment between valid values. @default 1 */
+    step?: number;
+    /** Called when the value changes via pointer or keyboard. */
+    onChange?: (value: number) => void;
+}
+/** Horizontal slider for picking a number between min and max with keyboard support. */
+declare function Slider({ value, defaultValue, min, max, step, disabled: disabledProp, onChange, className, style, unstyled, }: SliderProps): react_jsx_runtime.JSX.Element;
+
+/** Props for the Rate component. */
+interface RateProps extends BaseComponentProps, InteractiveProps {
+    /** Controlled rating value. */
+    value?: number;
+    /** Uncontrolled initial rating. @default 0 */
+    defaultValue?: number;
+    /** Number of rating symbols. @default 5 */
+    count?: number;
+    /** Allows selecting half steps between stars. */
+    allowHalf?: boolean;
+    /** Custom node rendered for each rating symbol. @default '★' */
+    character?: React__default.ReactNode;
+    /** Called when the rating value changes. */
+    onChange?: (value: number) => void;
+}
+/** Star-style rating with hover preview, half steps, and keyboard adjustment. */
+declare function Rate({ value, defaultValue, count, disabled: disabledProp, allowHalf, character, onChange, className, style, unstyled, }: RateProps): react_jsx_runtime.JSX.Element;
+
+/** File entry shown in the upload list after selection or simulated progress. */
+interface UploadFile {
+    /** Stable unique id for list keys and remove callbacks. */
+    uid: string;
+    /** Display file name. */
+    name: string;
+    /** File size in bytes. */
+    size: number;
+    /** Visual state in the file list row. */
+    status: 'uploading' | 'done' | 'error';
+}
+/** Props for the file picker trigger, optional custom trigger, and file list UI. */
+interface UploadProps extends BaseComponentProps, InteractiveProps {
+    /** Passed to the hidden `<input type="file">` accept attribute. */
+    accept?: string;
+    /** Allows selecting more than one file per dialog when supported. */
+    multiple?: boolean;
+    /** Files to render in the list below the trigger. @default [] */
+    fileList?: UploadFile[];
+    /** Caps how many new files are passed to `onUpload` relative to current list length. */
+    maxCount?: number;
+    /** Called with chosen files after the user confirms the native picker. */
+    onUpload?: (files: File[]) => void;
+    /** Called when the user removes a completed or errored list item. */
+    onRemove?: (file: UploadFile) => void;
+    /** Custom trigger; defaults to a primary Upload button. */
+    children?: React__default.ReactNode;
+}
+/**
+ * Hidden file input with a clickable trigger and optional controlled file list with remove actions.
+ */
+declare function Upload({ accept, multiple, disabled: disabledProp, loading, fileList, maxCount, onUpload, onRemove, children, className, style, unstyled, }: UploadProps): react_jsx_runtime.JSX.Element;
+
+/** Visual variant for notification styling and icon. */
+type NotificationType = 'success' | 'error' | 'warning' | 'info';
+/** Options passed to `notification.open` and shorthand helpers. */
+interface NotificationConfig {
+    /** Notification style variant; defaults to `info` when omitted in the card. */
+    type?: NotificationType;
+    /** Primary line of text (title). */
+    message: React__default.ReactNode;
+    /** Optional secondary detail below the message. */
+    description?: React__default.ReactNode;
+    /** Auto-dismiss delay in ms; `0` disables auto-close. */
+    duration?: number;
+    /** Stable id for deduplication; a generated id is used if omitted. */
+    key?: string;
+    /** Called after the notification is removed (manual or auto). */
+    onClose?: () => void;
+    /** Corner stack this toast belongs to; must match a mounted container. */
+    placement?: 'topRight' | 'topLeft' | 'bottomRight' | 'bottomLeft';
+}
+declare const notification: {
+    open: (config: NotificationConfig) => void;
+    success: (message: React__default.ReactNode, description?: React__default.ReactNode) => void;
+    error: (message: React__default.ReactNode, description?: React__default.ReactNode) => void;
+    warning: (message: React__default.ReactNode, description?: React__default.ReactNode) => void;
+    info: (message: React__default.ReactNode, description?: React__default.ReactNode) => void;
+    destroy: () => void;
+};
+/** Props for the region that renders toasts for one corner placement. */
+interface NotificationContainerProps extends BaseComponentProps {
+    /** Which corner this container listens to; filters incoming notifications. @default 'topRight' */
+    placement?: 'topRight' | 'topLeft' | 'bottomRight' | 'bottomLeft';
+}
+/**
+ * Subscribes to the global notification store and renders matching toasts.
+ * Mount one instance per `placement` you use (typically in app root).
+ */
+declare function NotificationContainer({ placement, unstyled, }: NotificationContainerProps): react_jsx_runtime.JSX.Element | null;
+
+/** Props for the slide-in drawer panel. */
+interface DrawerProps extends BaseComponentProps {
+    /** When `true`, the drawer is visible. */
+    open: boolean;
+    /** Called when the drawer should close (Escape, mask, or close button). */
+    onClose: () => void;
+    /** Optional header content next to the close control. */
+    title?: React__default.ReactNode;
+    /** Main drawer body content. */
+    children?: React__default.ReactNode;
+    /** Optional footer region (e.g. actions). */
+    footer?: React__default.ReactNode;
+    /** Edge from which the panel enters. @default 'right' */
+    placement?: 'left' | 'right' | 'top' | 'bottom';
+    /** Width for left/right placement (CSS length or pixels). @default 378 */
+    width?: number | string;
+    /** Height for top/bottom placement (CSS length or pixels). @default 378 */
+    height?: number | string;
+    /** When `true`, shows a header close button. @default true */
+    closable?: boolean;
+    /** When `true`, renders a dimmed mask behind the panel. @default true */
+    mask?: boolean;
+    /** When `true`, clicking the mask calls `onClose`. @default true */
+    maskClosable?: boolean;
+}
+/**
+ * Side panel drawer with optional mask, placement transitions, and focus trap.
+ * Horizontal placement uses `width`; vertical uses `height`.
+ */
+declare function Drawer({ open, onClose, title, children, footer, placement, width, height, closable, mask, maskClosable, className, style, unstyled, }: DrawerProps): react_jsx_runtime.JSX.Element | null;
+
+/** Props for the confirmation bubble anchored to a trigger element. */
+interface PopconfirmProps extends BaseComponentProps {
+    /** Main confirmation question or summary. */
+    title: React__default.ReactNode;
+    /** Optional supporting text below the title. */
+    description?: React__default.ReactNode;
+    /** Called when the user confirms. */
+    onConfirm?: () => void;
+    /** Called when the user cancels or dismisses without confirming. */
+    onCancel?: () => void;
+    /** Label for the confirm action button. @default 'Yes' */
+    okText?: string;
+    /** Label for the cancel action button. @default 'No' */
+    cancelText?: string;
+    /** Popover position relative to the trigger. @default 'top' */
+    placement?: 'top' | 'bottom' | 'left' | 'right';
+    /** Single React element that opens the popconfirm on click. */
+    children: React__default.ReactElement;
+    /** When `true`, the trigger does not open the popconfirm. */
+    disabled?: boolean;
+}
+/**
+ * Lightweight confirm dialog on click: wraps a trigger and shows OK/Cancel.
+ * Closes on outside click or after confirm/cancel.
+ */
+declare function Popconfirm({ title, description, onConfirm, onCancel, okText: okTextProp, cancelText: cancelTextProp, placement, children, disabled, className, unstyled, }: PopconfirmProps): react_jsx_runtime.JSX.Element;
+
+/** Props for the Badge component (count, dot, or status ribbon). */
+interface BadgeProps extends BaseComponentProps, SizableProps {
+    /** Numeric value shown in the badge; hidden when zero unless `showZero`. */
+    count?: number;
+    /** Renders a small dot indicator instead of a numeric count. */
+    dot?: boolean;
+    /** Maximum count before showing `{overflowCount}+`. @default 99 */
+    overflowCount?: number;
+    /** When true, shows the badge even when `count` is zero. */
+    showZero?: boolean;
+    /** Custom background color for the dot or count (CSS color). */
+    color?: string;
+    /** Preset status style for standalone status badges. */
+    status?: 'success' | 'error' | 'warning' | 'processing' | 'default';
+    /** Text shown next to the status dot when `status` is set. */
+    text?: React__default.ReactNode;
+    /** Pixel offset `[right, top]` for the dot or count position. */
+    offset?: [number, number];
+    /** Wrapped trigger element (e.g. icon or avatar). */
+    children?: React__default.ReactNode;
+}
+/**
+ * Displays a notification count, dot, or status label on a child element.
+ */
+declare function Badge({ count, dot, overflowCount, showZero, color, status, text, offset, children, className, style, unstyled, }: BadgeProps): react_jsx_runtime.JSX.Element;
+
+/** Props for the Tag component (label with optional close control). */
+interface TagProps extends BaseComponentProps, SizableProps {
+    /** Preset semantic color or any CSS color string for custom tags. @default 'default' */
+    color?: 'default' | 'success' | 'error' | 'warning' | 'processing' | string;
+    /** Shows a close control when true. */
+    closable?: boolean;
+    /** Called when the close control is activated. */
+    onClose?: () => void;
+    /** Whether to show a border around the tag. @default true */
+    bordered?: boolean;
+    /** Tag label content. */
+    children: React__default.ReactNode;
+}
+/**
+ * Inline label tag with optional preset colors and closable behavior.
+ */
+declare function Tag({ color, closable, onClose, bordered, children, className, style, unstyled, }: TagProps): react_jsx_runtime.JSX.Element;
+
+/** Props for the Avatar component (image, icon, or text fallback). */
+interface AvatarProps extends BaseComponentProps {
+    /** Image URL when displaying a photo avatar. */
+    src?: string;
+    /** Alt text for the image when `src` is set. */
+    alt?: string;
+    /** Accessible name for the avatar when there is no visible text. */
+    'aria-label'?: string;
+    /** Width/height in px (number) or preset size token. */
+    size?: SizeType | number;
+    /** Outer shape of the avatar. @default 'circle' */
+    shape?: 'circle' | 'square';
+    /** Icon node shown when `src` is omitted. */
+    icon?: React__default.ReactNode;
+    /** Text or initials shown when neither `src` nor `icon` is set. */
+    children?: React__default.ReactNode;
+}
+/**
+ * Renders a user avatar from an image URL, icon, or text content.
+ */
+declare function Avatar({ src, alt, 'aria-label': ariaLabel, size: sizeProp, shape, icon, children, className, style, unstyled, }: AvatarProps): react_jsx_runtime.JSX.Element;
+
+/** One segment in the breadcrumb trail. */
+interface BreadcrumbItem {
+    /** Segment label or custom content. */
+    title: React__default.ReactNode;
+    /** When set, the segment renders as a link with this URL. */
+    href?: string;
+    /** Invoked on click; prevents navigation when `href` is also set. */
+    onClick?: () => void;
+}
+/** Props for the breadcrumb navigation list. */
+interface BreadcrumbProps extends BaseComponentProps {
+    /** Ordered trail from root to current location. */
+    items: BreadcrumbItem[];
+    /** Node rendered between segments. @default '/' */
+    separator?: React__default.ReactNode;
+}
+/** Renders a breadcrumb trail with optional links, custom separators, and current-page styling. */
+declare function Breadcrumb({ items, separator, className, style, unstyled, }: BreadcrumbProps): react_jsx_runtime.JSX.Element;
+
+/** Props for page navigation, optional total text, page size, and quick jump. */
+interface PaginationProps extends BaseComponentProps {
+    /** Current page number (1-based). */
+    current: number;
+    /** Total number of records across all pages. */
+    total: number;
+    /** Number of items per page. @default 10 */
+    pageSize?: number;
+    /** Called when the user selects a different page. */
+    onChange?: (page: number) => void;
+    /** Called when the user picks a new value from the size changer. */
+    onPageSizeChange?: (size: number) => void;
+    /** Renders total count text, or a custom node from total and visible range. */
+    showTotal?: boolean | ((total: number, range: [number, number]) => React__default.ReactNode);
+    /** Disables all controls; falls back to ConfigProvider when omitted. */
+    disabled?: boolean;
+    /** Renders prev/next with current/total only, hiding page numbers. */
+    simple?: boolean;
+    /** Shows a select to change `pageSize`. */
+    showSizeChanger?: boolean;
+    /** Options for the page size select. @default [10, 20, 50, 100] */
+    pageSizeOptions?: number[];
+    /** Shows an input to jump to a page by number. */
+    showQuickJumper?: boolean;
+}
+/**
+ * Page controls with numbered pages, ellipsis folding, and optional size changer and jumper.
+ * Clamps the current page into valid range for the given total and page size.
+ */
+declare function Pagination({ current, total, pageSize, onChange, onPageSizeChange, showTotal, disabled: disabledProp, simple, showSizeChanger, pageSizeOptions, showQuickJumper, className, style, unstyled, }: PaginationProps): react_jsx_runtime.JSX.Element;
+
+/** One entry in the dropdown menu: action row or non-interactive divider. */
+interface DropdownItem {
+    /** Unique key passed to `onSelect` when the row is activated. */
+    key: string;
+    /** Visible menu row content. */
+    label: React__default.ReactNode;
+    /** When true, the row cannot be selected. */
+    disabled?: boolean;
+    /** When true, styles the row as a destructive action. */
+    danger?: boolean;
+    /** When true, renders a separator instead of a selectable row. */
+    divider?: boolean;
+}
+/** Props for the trigger + anchored menu dropdown. */
+interface DropdownProps extends BaseComponentProps {
+    /** Menu rows and optional dividers. */
+    items: DropdownItem[];
+    /** Called with the item `key` after a successful selection. */
+    onSelect?: (key: string) => void;
+    /** Opens the menu on click or hover. @default 'hover' */
+    trigger?: 'click' | 'hover';
+    /** Menu position relative to the trigger. @default 'bottomLeft' */
+    placement?: 'bottomLeft' | 'bottomRight' | 'topLeft' | 'topRight';
+    /** When true, ignores open/close and selection; uses ConfigProvider when omitted. */
+    disabled?: boolean;
+    /** Element rendered as the menu trigger. */
+    children: React__default.ReactElement;
+}
+/**
+ * Anchored menu opened by hover or click, with keyboard support and outside-click close.
+ * Styled variant uses a slide transition; unstyled variant renders a minimal structure.
+ */
+declare function Dropdown({ items, onSelect, trigger, placement, disabled: disabledProp, children, className, unstyled, }: DropdownProps): react_jsx_runtime.JSX.Element;
+
+/** Props for the Progress bar or circular progress indicator. */
+interface ProgressProps extends BaseComponentProps, SizableProps {
+    /** Completion value from 0 to 100 (clamped). */
+    percent: number;
+    /** Renders a horizontal bar or circular SVG progress. @default 'line' */
+    type?: 'line' | 'circle';
+    /** Visual state; `normal` becomes success at 100%. @default 'normal' */
+    status?: 'normal' | 'success' | 'error' | 'active';
+    /** Shows percentage text next to or inside the indicator. @default true */
+    showInfo?: boolean;
+    /** Bar or circle stroke thickness in pixels. */
+    strokeWidth?: number;
+    /** Custom color for the filled portion of the progress. */
+    strokeColor?: string;
+    /** SVG width/height for circle type. @default 120 */
+    width?: number;
+}
+/**
+ * Displays task completion as a line or circle, with optional percentage label.
+ */
+declare function Progress({ percent, type, status, showInfo, strokeWidth, strokeColor, size: sizeProp, width, className, style, unstyled, }: ProgressProps): react_jsx_runtime.JSX.Element;
+
+/** Single menu entry: leaf item, submenu, group heading, or divider. */
+interface MenuItem {
+    /** Unique key for selection and open-state tracking. */
+    key: string;
+    /** Visible label or custom node. */
+    label: ReactNode;
+    /** Optional icon shown before the label. */
+    icon?: ReactNode;
+    /** When true, the item cannot be activated. */
+    disabled?: boolean;
+    /** When true, styles the item as a destructive action. */
+    danger?: boolean;
+    /** Nested items for a submenu; omit for a leaf. */
+    children?: MenuItem[];
+    /** Renders as a titled group or a non-interactive divider. */
+    type?: 'group' | 'divider';
+}
+/** Props for the hierarchical menu with optional inline, horizontal, or vertical layout. */
+interface MenuProps extends BaseComponentProps, SizableProps {
+    /** Top-level menu items (may include groups and nested submenus). */
+    items: MenuItem[];
+    /** Layout and interaction mode for the root menu. @default 'vertical' */
+    mode?: 'vertical' | 'horizontal' | 'inline';
+    /** Controlled list of selected item keys. */
+    selectedKeys?: string[];
+    /** Initial selected keys when `selectedKeys` is not set. @default [] */
+    defaultSelectedKeys?: string[];
+    /** Controlled list of keys for expanded inline submenus. */
+    openKeys?: string[];
+    /** Initial open submenu keys when `openKeys` is not set. @default [] */
+    defaultOpenKeys?: string[];
+    /** Called after the user selects a leaf item. */
+    onSelect?: (info: {
+        key: string;
+        selectedKeys: string[];
+    }) => void;
+    /** Called when inline submenu expand/collapse state changes. */
+    onOpenChange?: (openKeys: string[]) => void;
+    /** Collapses inline mode to icons only at the root level. @default false */
+    inlineCollapsed?: boolean;
+    /** Built-in color scheme for styled menus. @default 'light' */
+    theme?: 'light' | 'dark';
+}
+/**
+ * Renders an accessible menu tree with support for groups, dividers, and nested submenus.
+ * Supports controlled or uncontrolled selection and open keys.
+ */
+declare function Menu({ items, mode, selectedKeys, defaultSelectedKeys, openKeys, defaultOpenKeys, onSelect, onOpenChange, inlineCollapsed, theme, className, style, unstyled, }: MenuProps): react_jsx_runtime.JSX.Element;
+
+/** Single collapsible section: header, body, and optional metadata. */
+interface CollapseItem {
+    /** Unique key used for selection state and toggling. */
+    key: string;
+    /** Header content shown in the panel trigger. */
+    label: ReactNode;
+    /** Body content revealed when the panel is expanded. */
+    children: ReactNode;
+    /** Optional content rendered beside the header (e.g. actions). */
+    extra?: ReactNode;
+    /** When `false`, hides the expand/collapse arrow. */
+    showArrow?: boolean;
+    /** When `true`, the panel cannot be toggled. */
+    disabled?: boolean;
+}
+/** Props for the vertical accordion-style collapse list. */
+interface CollapseProps extends BaseComponentProps, SizableProps {
+    /** Panels to render, each with a stable `key`. */
+    items: CollapseItem[];
+    /** Controlled open keys; when set, overrides internal state. */
+    activeKey?: string | string[];
+    /** Initial open keys when uncontrolled. */
+    defaultActiveKey?: string | string[];
+    /** Called after the open set changes (controlled or uncontrolled). */
+    onChange?: (activeKey: string[]) => void;
+    /** When `true`, only one panel may be open at a time. @default false */
+    accordion?: boolean;
+    /** When `true`, draws a border around the collapse container. @default true */
+    bordered?: boolean;
+    /** Placement of the expand icon relative to the header text. @default 'start' */
+    expandIconPosition?: 'start' | 'end';
+    /** Transparent style without panel background borders. @default false */
+    ghost?: boolean;
+}
+/**
+ * Renders an expandable list of panels with optional accordion mode and styled or unstyled markup.
+ */
+declare function Collapse({ items, activeKey, defaultActiveKey, onChange, accordion, bordered, expandIconPosition, ghost, size: sizeProp, className, style, unstyled, }: CollapseProps): react_jsx_runtime.JSX.Element;
+
+/** Props for a color swatch trigger with saturation/hue panel and optional presets. */
+interface ColorPickerProps extends BaseComponentProps, InteractiveProps, SizableProps {
+    /** Controlled color as hex (#rrggbb) or rgb(...) string matching parse rules. */
+    value?: string;
+    /** Initial color when uncontrolled. */
+    defaultValue?: string;
+    /** Called when the color changes; receives string in the active format prop. */
+    onChange?: (color: string) => void;
+    /** Optional grouped preset swatches (label + color strings). */
+    presets?: Array<{
+        label: string;
+        colors: string[];
+    }>;
+    /** When true, show formatted text; when a function, render custom node beside swatch. */
+    showText?: boolean | ((color: string) => ReactNode);
+    /** String format used for display and onChange payload. */
+    format?: 'hex' | 'rgb';
+    /** Whether the panel opens on click or on hover (with a short leave delay). */
+    trigger?: 'click' | 'hover';
+    /** Controlled open state of the picker panel. */
+    open?: boolean;
+    /** Called when the panel opens or closes. */
+    onOpenChange?: (open: boolean) => void;
+    /**
+     * Accessible name for the trigger button. The trigger only shows a color
+     * swatch (and optional `showText`), so without a programmatic name axe
+     * `button-name` flags the control. Provide either `aria-label` or
+     * `aria-labelledby`; if `showText` renders text, that text is enough.
+     */
+    'aria-label'?: string;
+    /** Id(s) of the element(s) that label the trigger. Mirrors `aria-label`. */
+    'aria-labelledby'?: string;
+}
+/**
+ * Color picker with saturation/value square, hue strip, text input, and optional presets.
+ * Supports click or hover trigger and controlled or internal open state.
+ *
+ * @default format - `'hex'`
+ * @default trigger - `'click'`
+ */
+declare function ColorPicker({ value, defaultValue, onChange, presets, showText, size: sizeProp, disabled: disabledProp, format, trigger, open: controlledOpen, onOpenChange, className, style, unstyled, 'aria-label': ariaLabel, 'aria-labelledby': ariaLabelledBy, }: ColorPickerProps): react_jsx_runtime.JSX.Element;
+
+/** Props for the Empty state component. */
+interface EmptyProps extends BaseComponentProps {
+    /** Illustration or icon above the description; uses built-in art when omitted. */
+    image?: React__default.ReactNode;
+    /** Message below the image; defaults to "No Data" when undefined, hidden when null. */
+    description?: React__default.ReactNode;
+    /** Optional footer actions or supplementary content. */
+    children?: React__default.ReactNode;
+}
+/**
+ * Presents a no-data state with optional image, description, and footer slot.
+ */
+declare function Empty({ image, description, children, className, style, unstyled, }: EmptyProps): react_jsx_runtime.JSX.Element;
+
+/** Props for the Result feedback page (status, title, and optional actions). */
+interface ResultProps extends BaseComponentProps {
+    /** Outcome type controlling default icon and styling. */
+    status: 'success' | 'error' | 'info' | 'warning' | '404' | '403' | '500';
+    /** Primary heading for the result. */
+    title: React__default.ReactNode;
+    /** Secondary explanatory text below the title. */
+    subTitle?: React__default.ReactNode;
+    /** Replaces the default icon for the given `status`. */
+    icon?: React__default.ReactNode;
+    /** Actions or buttons shown below the titles (e.g. primary CTA). */
+    extra?: React__default.ReactNode;
+    /** Additional body content below `extra`. */
+    children?: React__default.ReactNode;
+}
+/**
+ * Full-page or section result layout with preset icons for common HTTP and feedback states.
+ */
+declare function Result({ status, title, subTitle, icon, extra, children, className, style, unstyled, }: ResultProps): react_jsx_runtime.JSX.Element;
+
+/** Props for the Skeleton loading placeholder layout. */
+interface SkeletonProps extends BaseComponentProps {
+    /** Enables a shimmering animation on placeholders. @default false */
+    active?: boolean;
+    /** Shows an avatar block; pass an object for `size` and `shape`. */
+    avatar?: boolean | {
+        size?: number;
+        shape?: 'circle' | 'square';
+    };
+    /** Shows a title bar; pass an object for custom `width`. @default true */
+    title?: boolean | {
+        width?: number | string;
+    };
+    /** Shows paragraph lines; pass an object for `rows` and per-line `width`. @default true */
+    paragraph?: boolean | {
+        rows?: number;
+        width?: Array<number | string>;
+    };
+    /** When false, renders `children` instead of the skeleton. @default true */
+    loading?: boolean;
+    /** Real content shown when `loading` is false. */
+    children?: React__default.ReactNode;
+}
+/**
+ * Placeholder UI while content loads; supports avatar, title, and paragraph blocks.
+ */
+declare function Skeleton({ active, avatar, title, paragraph, loading, children, className, style, unstyled, }: SkeletonProps): react_jsx_runtime.JSX.Element;
+
+type SegmentedOption = string | {
+    label: React__default.ReactNode;
+    value: string;
+    icon?: React__default.ReactNode;
+    disabled?: boolean;
+};
+/** Props for a horizontal group of mutually exclusive segment choices. */
+interface SegmentedProps extends BaseComponentProps, InteractiveProps, SizableProps {
+    /** Segment definitions as strings or objects with label, value, and optional icon. */
+    options: SegmentedOption[];
+    /** Controlled selected segment value. */
+    value?: string;
+    /** Initial value when uncontrolled; falls back to first option value if unset. */
+    defaultValue?: string;
+    /** Called when the user selects a segment. */
+    onChange?: (value: string) => void;
+    /** When true, the control stretches to the full width of its container. */
+    block?: boolean;
+}
+/**
+ * Segmented control (radio group) for picking one of several options.
+ * Renders as styled pills or, when unstyled, as native radio inputs.
+ */
+declare function Segmented({ options, value, defaultValue, onChange, block, size: sizeProp, disabled: disabledProp, className, style, unstyled, }: SegmentedProps): react_jsx_runtime.JSX.Element;
+
+/** One step in a wizard or progress sequence. */
+interface StepItem {
+    /** Primary step title. */
+    title: React__default.ReactNode;
+    /** Optional secondary text below the title. */
+    description?: React__default.ReactNode;
+    /** Custom icon; defaults to checkmark, error mark, or index when omitted. */
+    icon?: React__default.ReactNode;
+    /** Overrides auto-derived status from `current` index. */
+    status?: 'wait' | 'process' | 'finish' | 'error';
+}
+/** Props for the step indicator sequence. */
+interface StepsProps extends BaseComponentProps, SizableProps {
+    /** Zero-based index of the active (in-progress) step. */
+    current: number;
+    /** Steps in display order. */
+    items: StepItem[];
+    /** Stack direction for the step list. @default 'horizontal' */
+    direction?: 'horizontal' | 'vertical';
+    /** When set, each step becomes clickable and reports its index. */
+    onChange?: (current: number) => void;
+    /** Visual variant: standard steps or navigation-style. @default 'default' */
+    type?: 'default' | 'navigation';
+}
+/**
+ * Displays a linear sequence of steps with icons, titles, and optional descriptions.
+ * Derives each step status from `current` unless overridden per item.
+ */
+declare function Steps({ current, items, direction, size: sizeProp, onChange, type, className, style, unstyled, }: StepsProps): react_jsx_runtime.JSX.Element;
+
+/** One entry on the timeline axis (content, optional label, and marker styling). */
+interface TimelineItem {
+    /** Main body content for this step. */
+    children: React__default.ReactNode;
+    /** Border/text color for the default dot when no custom `dot` is set. */
+    color?: string;
+    /** Custom marker node; replaces the default dot. */
+    dot?: React__default.ReactNode;
+    /** Optional label rendered beside or above the marker. */
+    label?: React__default.ReactNode;
+    /** Forces this item to the left or right side (overrides list `mode` for this index). */
+    position?: 'left' | 'right';
+}
+/** Props for the vertical timeline list with optional pending tail. */
+interface TimelineProps extends BaseComponentProps {
+    /** Ordered timeline steps. */
+    items: TimelineItem[];
+    /** Layout: fixed side, or alternating left/right per item. @default 'left' */
+    mode?: 'left' | 'right' | 'alternate';
+    /** When truthy, appends a pending item; if `true`, children of that item are empty. */
+    pending?: React__default.ReactNode | boolean;
+    /** Marker for the synthetic pending item when `pending` is set. */
+    pendingDot?: React__default.ReactNode;
+    /** When `true`, reverses the visual order of `items` (and pending). */
+    reverse?: boolean;
+}
+/**
+ * Displays a chronological list with axis, dots, and optional pending state.
+ */
+declare function Timeline({ items: rawItems, mode, pending, pendingDot, reverse, className, style, unstyled, }: TimelineProps): react_jsx_runtime.JSX.Element;
+
+/** Props for a simple slide carousel with dots and optional autoplay. */
+interface CarouselProps extends BaseComponentProps {
+    /** Advances to the next slide on an interval when there is more than one slide. @default false */
+    autoplay?: boolean;
+    /** Interval in ms between autoplay steps. @default 3000 */
+    autoplaySpeed?: number;
+    /** Shows dot controls to jump between slides (hidden when only one slide in styled mode). @default true */
+    dots?: boolean;
+    /** Where dot navigation is placed relative to the track. @default 'bottom' */
+    dotPosition?: 'top' | 'bottom' | 'left' | 'right';
+    /** Transition between slides: horizontal offset or crossfade. @default 'slide' */
+    effect?: 'slide' | 'fade';
+    /** Each direct child is treated as one slide. */
+    children: React__default.ReactNode;
+}
+/**
+ * Cycles through child slides with optional autoplay, dot navigation, and slide or fade transitions.
+ */
+declare function Carousel({ autoplay, autoplaySpeed, dots, dotPosition, effect, children, className, style, unstyled, }: CarouselProps): react_jsx_runtime.JSX.Element;
+
+/** Single label/value pair in a descriptions list. */
+interface DescriptionsItem {
+    /** Optional stable key for list reconciliation. */
+    key?: string;
+    /** Field label shown in the first cell or header row. */
+    label: React__default.ReactNode;
+    /** Value content paired with `label`. */
+    children: React__default.ReactNode;
+    /** Column span for this item within the grid (max `column`). */
+    span?: number;
+}
+/** Props for the Descriptions key-value table. */
+interface DescriptionsProps extends BaseComponentProps, SizableProps {
+    /** Optional heading above the descriptions table. */
+    title?: React__default.ReactNode;
+    /** Rows built from these items according to `column` and each item's `span`. */
+    items: DescriptionsItem[];
+    /** Renders a bordered table style. @default false */
+    bordered?: boolean;
+    /** Number of description columns per row. @default 3 */
+    column?: number;
+    /** Stacks labels and values in separate rows when vertical. @default 'horizontal' */
+    layout?: 'horizontal' | 'vertical';
+    /** Appends ":" after labels when true. @default true */
+    colon?: boolean;
+}
+/**
+ * Renders a responsive key-value table from `items`, with horizontal or vertical layout.
+ */
+declare function Descriptions({ title, items, bordered, column, size: sizeProp, layout, colon, className, style, unstyled, }: DescriptionsProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * A single field in an editor schema. This is a UI-aware projection over a
+ * JSON-Schema property — extra editor metadata (defaultValue, helpText, the
+ * stable client-side `id`) lives alongside the standard JSON-Schema bits.
+ *
+ * The `id` is opaque to JSON-Schema and only used by the editor to track a
+ * field across reorders / renames. When exporting to plain JSON-Schema the
+ * `id` is dropped (`name` is the JSON-Schema property key).
+ */
+interface EditorField {
+    /** Stable client-side identifier (survives renames / reorders). */
+    id: string;
+    /** JSON-Schema property key (i.e. `properties[name]`). */
+    name: string;
+    /** Display label (`title` in JSON-Schema). */
+    label: string;
+    /** Mapped to `AutoField.type` and back to a JSON-Schema `type` / `format`. */
+    type: FieldType;
+    /** Whether this field is in the schema-level `required` array. */
+    required?: boolean;
+    /** Min — `minLength` for string, `minimum` for number, `min` for slider. */
+    min?: number;
+    /** Max — `maxLength` for string, `maximum` for number, `max` for slider. */
+    max?: number;
+    /** RegExp source (string) for `pattern` validation on string fields. */
+    pattern?: string;
+    /** Default value applied when the form mounts. */
+    defaultValue?: unknown;
+    /** Inline help text rendered below the control. Editor-only. */
+    helpText?: string;
+    /** Placeholder for the rendered control. */
+    placeholder?: string;
+    /** Choices for select / radio. */
+    options?: AutoFieldOption[];
+}
+/**
+ * Top-level editor schema. We intentionally do NOT model nested groups /
+ * field-arrays in v1 (see TODO in adapters/jsonSchema.ts) — the field list
+ * is flat, mirroring `JSONSchema.properties`.
+ */
+interface EditorSchema {
+    /** Optional schema title shown in the live preview header. */
+    title?: string;
+    /** Optional schema description shown in the live preview header. */
+    description?: string;
+    /** Ordered list of fields. Order maps directly to render order. */
+    fields: EditorField[];
+}
+/**
+ * Discriminated union of all supported editor mutations. Routed through the
+ * store so undo / redo + onChange callbacks see a single point of truth.
+ */
+type EditorAction = {
+    type: 'add';
+    field: EditorField;
+    index?: number;
+} | {
+    type: 'remove';
+    id: string;
+} | {
+    type: 'update';
+    id: string;
+    patch: Partial<EditorField>;
+} | {
+    type: 'move';
+    id: string;
+    toIndex: number;
+} | {
+    type: 'setSchema';
+    schema: EditorSchema;
+};
+/** External, read-only snapshot of the editor store. */
+interface EditorState {
+    schema: EditorSchema;
+    selectedId: string | null;
+    canUndo: boolean;
+    canRedo: boolean;
+}
+
+/**
+ * Public store API surfaced by `useSchemaEditor`. Mutations are dispatched
+ * through `apply(action)` which handles undo / redo bookkeeping. Convenience
+ * methods (`addField`, `removeField`, ...) wrap the corresponding actions.
+ */
+interface SchemaEditorStore {
+    /** Live snapshot — re-rendered on every commit. */
+    state: EditorState;
+    /** Underlying Core instance (mirrored snapshot under `$sfe.snapshot`). */
+    core: Core;
+    apply: (action: EditorAction) => void;
+    addField: (field: EditorField, index?: number) => void;
+    removeField: (id: string) => void;
+    updateField: (id: string, patch: Partial<EditorField>) => void;
+    moveField: (id: string, toIndex: number) => void;
+    moveFieldUp: (id: string) => void;
+    moveFieldDown: (id: string) => void;
+    duplicateField: (id: string) => void;
+    setSchema: (schema: EditorSchema) => void;
+    setSelectedId: (id: string | null) => void;
+    undo: () => void;
+    redo: () => void;
+}
+interface UseSchemaEditorOptions {
+    /** Initial schema; defaults to an empty schema. */
+    initialSchema?: EditorSchema;
+    /** External Core instance (cross-engine coordination). */
+    core?: Core;
+    /** Fires after every successful mutation with the new schema. */
+    onChange?: (schema: EditorSchema) => void;
+}
+declare function useSchemaEditor(options?: UseSchemaEditorOptions): SchemaEditorStore;
+
+interface PaletteItem {
+    /** SkyGraph field type — passed through `dataTransfer` on drop. */
+    type: FieldType;
+    /** Display label in the palette. */
+    label: string;
+    /** One-line description shown under the label. */
+    hint?: string;
+    /** Single-character glyph (rendered as plain text — no emoji). */
+    glyph?: string;
+}
+/**
+ * Default catalogue rendered when the consumer doesn't pass `items`. The list
+ * is intentionally flat (no categorisation) so the v1 editor stays focused.
+ */
+declare const DEFAULT_PALETTE_ITEMS: PaletteItem[];
+/**
+ * Mime-type used by the palette → canvas drag transfer. Kept narrow so
+ * external drops (e.g. files into the page) do not collide.
+ */
+declare const PALETTE_DATA_TYPE = "application/x-sg-sfe-palette-type";
+interface SchemaFormEditorPaletteProps {
+    /** Override the default catalogue. */
+    items?: PaletteItem[];
+    /** Wrapper className (additive). */
+    className?: string;
+    /** Wrapper inline style. */
+    style?: CSSProperties;
+    /**
+     * Optional fallback callback when the host environment does not support
+     * HTML5 drag-and-drop (e.g. some test runners). The canvas listens for
+     * `onClick` on palette items to add a field at the end as a graceful
+     * degradation.
+     */
+    onItemActivate?: (type: FieldType) => void;
+}
+declare function SchemaFormEditorPalette({ items, className, style, onItemActivate, }: SchemaFormEditorPaletteProps): react_jsx_runtime.JSX.Element;
+
+interface SchemaFormEditorProps {
+    /** Initial schema (uncontrolled). Use `setSchema` from a custom store for controlled use. */
+    initialSchema?: EditorSchema;
+    /**
+     * Externally-managed editor store. When provided, `initialSchema`,
+     * `onChange` are ignored and the consumer drives the editor directly.
+     */
+    store?: SchemaEditorStore;
+    /** Override the default palette catalogue. */
+    paletteItems?: PaletteItem[];
+    /** Fires after every successful mutation with the new schema. */
+    onChange?: (schema: EditorSchema) => void;
+    /** Empty-state CTA. */
+    emptyText?: string;
+    /** Wrapper className (additive). */
+    className?: string;
+    /** Wrapper inline style. */
+    style?: CSSProperties;
+    /** Hide the bottom Preview / Schema toggle. Default is to show it. */
+    hideSchemaView?: boolean;
+}
+declare function SchemaFormEditor({ initialSchema, store: externalStore, paletteItems, onChange, emptyText, className, style, hideSchemaView, }: SchemaFormEditorProps): react_jsx_runtime.JSX.Element;
+
+interface SchemaFormEditorCanvasProps {
+    store: SchemaEditorStore;
+    /** Empty-state CTA text. */
+    emptyText?: string;
+    /** Wrapper className (additive). */
+    className?: string;
+    /** Wrapper inline style. */
+    style?: CSSProperties;
+}
+declare function SchemaFormEditorCanvas({ store, emptyText, className, style, }: SchemaFormEditorCanvasProps): react_jsx_runtime.JSX.Element;
+
+interface SchemaFormEditorInspectorProps {
+    store: SchemaEditorStore;
+    className?: string;
+    style?: CSSProperties;
+}
+declare function SchemaFormEditorInspector({ store, className, style, }: SchemaFormEditorInspectorProps): react_jsx_runtime.JSX.Element;
+
+interface SchemaFormEditorSchemaViewProps {
+    store: SchemaEditorStore;
+    className?: string;
+    style?: CSSProperties;
+    /** Output mode — formatted JSON or a TypeScript-friendly literal. */
+    mode?: 'json' | 'ts';
+}
+declare function SchemaFormEditorSchemaView({ store, className, style, mode, }: SchemaFormEditorSchemaViewProps): react_jsx_runtime.JSX.Element;
+
+/** Build an empty editor schema. Useful for the "blank canvas" demo. */
+declare function createEmptyEditorSchema(): EditorSchema;
+/**
+ * Convert a plain JSON Schema (the same shape `SchemaForm` accepts) to an
+ * `EditorSchema`. Property order is preserved (`Object.entries` is stable
+ * for string keys per ES2015).
+ */
+declare function jsonSchemaToEditorSchema(schema: JSONSchema): EditorSchema;
+/** Convert an `EditorSchema` back to a plain JSON Schema. */
+declare function editorSchemaToJsonSchema(editor: EditorSchema): JSONSchema;
+/**
+ * Factory for newly-dropped palette items. Keeps the per-type defaults in
+ * one place so the palette and the inspector agree on what e.g. a brand-new
+ * "Slider" should look like.
+ */
+declare function createFieldFromPaletteType(type: FieldType, existingNames: string[]): EditorField;
+
+interface UseGraphOptions extends GraphEngineOptions {
+    /** Bring your own Core instance (for cross-engine coordination). */
+    core?: Core;
+}
+interface UseGraphReturn {
+    /** Underlying engine — call mutating methods on this. */
+    graph: GraphEngine;
+    /** Reactive snapshot of nodes / edges / edgesByNode. */
+    state: GraphState;
+    /** The Core instance backing the engine (own or borrowed). */
+    core: Core;
+}
+/**
+ * Reactive bridge between `createGraph` (from `@skygraph/core`) and React.
+ *
+ * The hook creates (or reuses) a Core + Graph pair, subscribes to the
+ * `$graph.snapshot.*` namespace, and re-renders the consumer on every commit.
+ *
+ * The graph object reference is stable across renders. Mutations go through
+ * `graph.addNode(...)`, `graph.moveNode(...)`, etc.
+ */
+declare function useGraph(options?: UseGraphOptions): UseGraphReturn;
+
+/**
+ * Mini-toolbar entry rendered above a hovered `GraphNode` (from
+ * `@skygraph/core`). The `onClick` receives the original node so handlers
+ * can run engine mutations (e.g. `graph.removeNode(node.id)`) without
+ * re-resolving by id.
+ */
+interface NodeAction {
+    /** Stable key — also the value reflected in `data-action-id`. */
+    id: string;
+    /** Custom React content (icon / SVG); falls back to `label`. */
+    icon?: ReactNode;
+    /** Label rendered next to / instead of the icon, also used as `aria-label`. */
+    label?: string;
+    /** Click handler. */
+    onClick: (node: GraphNode, event: MouseEvent<HTMLButtonElement>) => void;
+    /**
+     * Optional predicate hiding the action for some nodes. Re-evaluated on
+     * every render so it can react to per-node `data` changes.
+     */
+    hidden?: (node: GraphNode) => boolean;
+}
+/** Same shape as `NodeAction`, but rendered above a hovered edge. */
+interface EdgeAction {
+    id: string;
+    icon?: ReactNode;
+    label?: string;
+    onClick: (edge: GraphEdge, event: MouseEvent<HTMLButtonElement>) => void;
+    hidden?: (edge: GraphEdge) => boolean;
+}
+
+/** Imperative API of {@link Diagram}. */
+interface DiagramRef {
+    /**
+     * Открыть popup и вызвать window.print() на DOM-области диаграммы. Объекты
+     * `customStyles` / `pageSize` / `orientation` мерджатся с тем, что пришло
+     * через prop `printable`.
+     */
+    print: (opts?: PrintOptions) => void;
+}
+/**
+ * Per-node renderer. Receives the engine node and returns the React content
+ * placed inside the absolutely-positioned wrapper. If omitted, a default
+ * label (`node.id`) is rendered.
+ */
+type DiagramNodeRenderer = (node: GraphNode) => ReactNode;
+/** Selection management mode for the diagram. */
+type DiagramSelectionMode = 'single' | 'multi' | 'lasso';
+/**
+ * Argument passed to {@link DiagramProps.onCanvasContextMenu} — combines
+ * world-space and screen-space coordinates so consumers can position a
+ * floating menu without re-projecting.
+ */
+interface DiagramCanvasContextPoint {
+    /** World-space x (matches `node.transform.x`). */
+    x: number;
+    /** World-space y. */
+    y: number;
+    /** Browser-screen x (`event.clientX`). */
+    screenX: number;
+    /** Browser-screen y (`event.clientY`). */
+    screenY: number;
+}
+/**
+ * Argument passed to {@link DiagramProps.onDropNode} when a draggable
+ * HTML5 element is dropped on the canvas. Combines world-space
+ * coordinates (already adjusted for pan / zoom) with the underlying
+ * `DragEvent` so consumers can pull whatever payload they encoded.
+ */
+interface DiagramDropPoint {
+    /** World-space x where the cursor was released. */
+    x: number;
+    /** World-space y where the cursor was released. */
+    y: number;
+    /** Browser-screen x (`event.clientX`). */
+    screenX: number;
+    /** Browser-screen y (`event.clientY`). */
+    screenY: number;
+    /** The original native `DataTransfer` so the consumer can decode the payload. */
+    dataTransfer: DataTransfer | null;
+}
+interface DiagramProps {
+    /** GraphEngine driving the diagram (e.g. from `useGraph()`). */
+    graph: GraphEngine;
+    /**
+     * Snapshot of the graph state (from `useGraph().state`). Required so that
+     * the component re-renders on every commit.
+     */
+    state: GraphState;
+    /** Width of the canvas; defaults to a flexible 100%. */
+    width?: number | string;
+    /** Height of the canvas; defaults to 400. */
+    height?: number | string;
+    /** Optional content renderer per node. */
+    renderNode?: DiagramNodeRenderer;
+    /** Root wrapper className. */
+    className?: string;
+    /** Root wrapper inline style. */
+    style?: CSSProperties;
+    /** Drop the default `sg-diagram-*` class names. */
+    unstyled?: boolean;
+    /**
+     * Enable click-and-drag to move nodes. The handler receives the new
+     * position in the parent's coordinate space and is expected to call
+     * `graph.moveNode(...)` (the default handler does exactly this).
+     *
+     * Set `true` for the default behaviour, `false` (default) to disable,
+     * or pass a custom function for richer drag logic (e.g. snap-to-grid,
+     * permission checks).
+     *
+     * @default false
+     */
+    draggable?: boolean | ((id: NodeId, x: number, y: number) => void);
+    /**
+     * Enable mouse-wheel zoom (`Ctrl + wheel`) and pinch-zoom-style scaling.
+     * The internal canvas is wrapped in a `<g>` / `<div>` whose CSS
+     * transform reflects the current zoom factor.
+     *
+     * @default false
+     */
+    zoomable?: boolean;
+    /**
+     * Enable panning. Plain mouse-wheel scrolls the canvas; the middle
+     * mouse button drags it. `Ctrl + wheel` is reserved for zoom (when
+     * `zoomable` is also on), so the two flags compose cleanly.
+     *
+     * @default false
+     */
+    panable?: boolean;
+    /**
+     * Snap node coordinates to a grid of this size (world units). When set,
+     * `moveNode` is called with rounded `(x, y)` and the wrapper picks up
+     * the `sg-diagram-grid` class so a CSS background pattern renders.
+     *
+     * Pass `0` or `undefined` to disable.
+     */
+    snapToGrid?: number;
+    /**
+     * When `true`, orthogonal edges receive the AABBs of every other node
+     * as obstacles so the A*-based router can avoid them. Off by default to
+     * keep the cheap L-route path the norm; opt in only when the diagram
+     * tends to have crossings worth avoiding.
+     *
+     * Independent of `routing` per edge — edges with `routing !== 'orthogonal'`
+     * ignore this flag.
+     */
+    routeAroundNodes?: boolean;
+    /**
+     * Tuning knobs forwarded to the edge router. `gridSize` / `inflate` /
+     * `maxNodes` only apply to `routing: 'orthogonal'` when
+     * `routeAroundNodes` is on (see `routeOrthogonal` in `@skygraph/core`).
+     *
+     *   • `cornerRadius` — radius of rounded corners on orthogonal
+     *     edges. Defaults to `8` world units. Pass `0` for sharp
+     *     right-angle corners.
+     *   • `curvature` — control-handle intensity for `routing: 'bezier'`.
+     *     Defaults to React Flow's `0.25`. Range: `0..1`.
+     */
+    routingOptions?: {
+        gridSize?: number;
+        inflate?: number;
+        maxNodes?: number;
+        cornerRadius?: number;
+        curvature?: number;
+    };
+    /**
+     * When `true`, every rendered edge gets an arrow marker on its target
+     * end (matches the visual norm of mainstream diagram libraries).
+     * The marker reuses the edge stroke colour through `currentColor`
+     * so hover / selected styles propagate automatically.
+     *
+     * @default true
+     */
+    edgeArrows?: boolean;
+    /**
+     * Включает поддержку печати через `ref.print()`. Если `true` — без
+     * визуальных изменений; объект `{ fileName }` задаёт имя popup-окна
+     * (используется как title и дефолт для "Save as PDF").
+     *
+     * Сама печать триггерится императивно через `ref.print()`.
+     * @default false
+     */
+    printable?: PrintableProp;
+    /**
+     * Right-click on a node — fired with the original mouse event and the
+     * engine node. If defined, the component calls `event.preventDefault()`
+     * and the browser's native context menu is suppressed. If omitted, the
+     * native menu shows as usual.
+     */
+    onNodeContextMenu?: (event: MouseEvent<HTMLDivElement>, node: GraphNode) => void;
+    /**
+     * Right-click on an edge path. Same suppression contract as
+     * {@link DiagramProps.onNodeContextMenu}.
+     */
+    onEdgeContextMenu?: (event: MouseEvent<SVGPathElement>, edge: GraphEdge) => void;
+    /**
+     * Right-click on the empty canvas (i.e. neither a node nor an edge).
+     * The point combines world and screen coordinates so a floating menu
+     * can be positioned without re-projection.
+     */
+    onCanvasContextMenu?: (event: MouseEvent<HTMLDivElement>, point: DiagramCanvasContextPoint) => void;
+    /**
+     * Mini-toolbar entries shown above a hovered node. The overlay is
+     * rendered in screen-space, so its size stays constant under
+     * pan / zoom. Show / hide use a 200 ms enter delay and 150 ms leave
+     * grace so the cursor can hop from the node to the overlay.
+     */
+    nodeActions?: readonly NodeAction[];
+    /** Same as {@link DiagramProps.nodeActions} but rendered next to a hovered edge. */
+    edgeActions?: readonly EdgeAction[];
+    /**
+     * Controlled selection: array of selected node ids. Pair with
+     * {@link DiagramProps.onSelectionChange}. If left undefined, the
+     * component manages selection internally (uncontrolled).
+     */
+    selection?: readonly NodeId[];
+    /** Initial selection for the uncontrolled mode. */
+    defaultSelection?: readonly NodeId[];
+    /** Fired whenever the selection changes (both controlled and uncontrolled). */
+    onSelectionChange?: (selection: NodeId[]) => void;
+    /**
+     * - `'single'` (default) — legacy behaviour; no multi-select, no lasso.
+     * - `'multi'` — `Ctrl+click` toggles selection; dragging a selected
+     *   node moves all selected together.
+     * - `'lasso'` — same as `'multi'` plus a left-button drag on empty
+     *   canvas opens a rubber-band rectangle selecting nodes whose AABBs
+     *   intersect it.
+     *
+     * Defaults to `'single'` for backwards compatibility — existing drag
+     * code keeps working unchanged.
+     */
+    selectionMode?: DiagramSelectionMode;
+    /**
+     * Fired when an HTML5 drag-and-drop ends on the canvas. The handler
+     * receives world-space coordinates (already adjusted for pan / zoom)
+     * plus the raw `DataTransfer` so the consumer can decode whatever
+     * payload it set on `dragStart`.
+     *
+     * The wrapper automatically wires `onDragOver = preventDefault` so
+     * drop targets work without extra config. Passing `undefined` leaves
+     * the canvas inert.
+     */
+    onDropNode?: (point: DiagramDropPoint) => void;
+    /**
+     * Comma-separated list of MIME types accepted by the canvas. When the
+     * dragged payload doesn't include any of these types, the drop is
+     * ignored (the cursor falls back to "no-drop"). Defaults to
+     * `['application/x-sg-node']` — the convention used by Skygraph
+     * palette items. Pass `'*'` (string) or `null` to accept everything.
+     */
+    dropTypes?: readonly string[] | '*' | null;
+}
+/**
+ * Reactive diagram view (forwardRef-обёртка над `DiagramInner`). Обновлять
+ * данные нужно через `graph` / `state`; для печати — `ref.print()`.
+ */
+declare const Diagram: React$1.ForwardRefExoticComponent<DiagramProps & React$1.RefAttributes<DiagramRef>>;
+
+/**
+ * One entry in the widget's hover-actions menu (`⋯` button at the
+ * widget's top-right). Each widget may declare its own `actions`; if the
+ * widget omits the field, `DashboardEditor` falls back to a default set
+ * (see `DashboardEditorProps`'s `onWidgetRefresh` / `onWidgetSettings`
+ * / `onWidgetRemove`).
+ */
+interface WidgetAction {
+    /** Stable id (used as React key + data-action-id). */
+    id: string;
+    /** Visible label. */
+    label: ReactNode;
+    /** Optional icon rendered before the label. */
+    icon?: ReactNode;
+    /**
+     * Click handler. Receives the widget the action is attached to. The
+     * action menu closes automatically before the callback runs.
+     */
+    onClick: (widget: DashboardWidget) => void;
+    /** Visual variant. `danger` paints the row red. @default 'default' */
+    variant?: 'default' | 'danger';
+    /**
+     * When the predicate returns `true`, the action is omitted from the
+     * menu for this widget. Useful for context-sensitive actions
+     * (e.g. hiding `Restore` when the widget isn't maximized).
+     */
+    hidden?: (widget: DashboardWidget) => boolean;
+}
+/** A single widget pinned to a CSS-grid cell range. */
+interface DashboardWidget {
+    /** Stable id (used as React key + data-widget-id). */
+    id: string;
+    /** Display title (rendered in the widget header by default). */
+    title?: ReactNode;
+    /** 1-based column index (`gridColumnStart`). */
+    x: number;
+    /** 1-based row index (`gridRowStart`). */
+    y: number;
+    /** Column span. @default 1 */
+    w?: number;
+    /** Row span. @default 1 */
+    h?: number;
+    /** Widget content. Either `children` or a `render` callback. */
+    children?: ReactNode;
+    /** Optional renderer (alternative to `children`). */
+    render?: () => ReactNode;
+    /** Optional className applied to the widget wrapper. */
+    className?: string;
+    /** Optional inline style for the widget wrapper. */
+    style?: CSSProperties;
+    /**
+     * Optional per-widget hover actions. When omitted, `DashboardEditor`
+     * synthesises a default set (`Refresh`, `Maximize`, `Settings`,
+     * `Remove`) from the editor-level callbacks.
+     *
+     * Pass an empty array to opt out of the actions menu entirely while
+     * still defining the field.
+     */
+    actions?: readonly WidgetAction[];
+}
+/** Callback fired when the user right-clicks a widget body. */
+type DashboardWidgetContextMenuHandler = (event: MouseEvent<HTMLDivElement>, widget: DashboardWidget) => void;
+/** Callback fired when the user right-clicks the dashboard background. */
+type DashboardContextMenuHandler = (event: MouseEvent<HTMLDivElement>) => void;
+/**
+ * Common props shared by `Dashboard` and `DashboardEditor` for the
+ * widget-actions / context-menu / maximize layer. Kept as a separate
+ * type so the editor-only props (drag, resize, layout-change) don't
+ * leak into the read-only `Dashboard`.
+ */
+interface DashboardCommonProps {
+    /**
+     * Right-click handler for individual widgets. When provided, the
+     * default browser menu is suppressed (`event.preventDefault()`) and
+     * the callback receives the synthetic event + the widget data.
+     *
+     * Mirrors the convention used by `Diagram` for canvas/node menus.
+     */
+    onWidgetContextMenu?: DashboardWidgetContextMenuHandler;
+    /**
+     * Right-click handler for the dashboard background (anywhere outside
+     * a widget). When provided, the default browser menu is suppressed
+     * and the callback receives the synthetic event.
+     */
+    onDashboardContextMenu?: DashboardContextMenuHandler;
+}
+
+interface DashboardProps extends DashboardCommonProps {
+    /** Widgets pinned to grid cells. */
+    widgets: readonly DashboardWidget[];
+    /** Total grid columns. @default 12 */
+    columns?: number;
+    /** Row height in pixels (uniform). @default 80 */
+    rowHeight?: number;
+    /** Gap between cells in pixels. @default 16 */
+    gap?: number;
+    /** Drop default `sg-dashboard-*` classes. */
+    unstyled?: boolean;
+    /** Root wrapper className. */
+    className?: string;
+    /** Root wrapper inline style. */
+    style?: CSSProperties;
+}
+/**
+ * Minimal static-layout dashboard.
+ *   - CSS Grid with `columns` columns and a uniform `rowHeight`.
+ *   - Each widget pins to its `(x, y, w, h)` cell range.
+ *   - Optional per-widget `actions` menu (`⋯` button on hover).
+ *   - Optional `onWidgetContextMenu` / `onDashboardContextMenu` callbacks
+ *     follow the same convention as `Diagram`: `preventDefault()` is
+ *     only called when the consumer passed a handler.
+ *
+ * Drag / resize / auto-pack live in `DashboardEditor`, not here.
+ */
+declare function Dashboard({ widgets, columns, rowHeight, gap, unstyled, className, style, onWidgetContextMenu, onDashboardContextMenu, }: DashboardProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Patch describing a layout change for one widget. Only the changed fields
+ * are present, so consumers can spread it onto their existing widget state.
+ */
+type DashboardLayoutPatch = Partial<Pick<DashboardWidget, 'x' | 'y' | 'w' | 'h'>>;
+/**
+ * Callback signature: receives the full updated widgets array (already
+ * patched with the new `(x, y, w, h)` for the affected widget). Designed
+ * for `onLayoutChange={setWidgets}`.
+ */
+type DashboardLayoutChange = (next: DashboardWidget[], meta: {
+    widgetId: string;
+    patch: DashboardLayoutPatch;
+}) => void;
+interface DashboardEditorProps extends DashboardCommonProps {
+    /** Widgets pinned to grid cells. */
+    widgets: readonly DashboardWidget[];
+    /**
+     * Called whenever a widget is dragged or resized to a new cell. Receives
+     * the full updated widgets array. Skipped when no actual layout change
+     * occurred (drag inside the same cell).
+     */
+    onLayoutChange?: DashboardLayoutChange;
+    /** Total grid columns. @default 12 */
+    columns?: number;
+    /** Row height in pixels (uniform). @default 80 */
+    rowHeight?: number;
+    /** Gap between cells in pixels. @default 16 */
+    gap?: number;
+    /**
+     * When `false`, drag / resize handlers are disabled and the editor renders
+     * read-only (still keeps the resize-handle DOM hidden). @default true
+     */
+    editable?: boolean;
+    /** Drop default `sg-dashboard-*` classes. */
+    unstyled?: boolean;
+    /** Root wrapper className. */
+    className?: string;
+    /** Root wrapper inline style. */
+    style?: CSSProperties;
+    /**
+     * Optional Refresh handler. When provided, the default action set
+     * (used when a widget doesn't declare its own `actions`) gains a
+     * `Refresh` entry that calls this with the widget data.
+     */
+    onWidgetRefresh?: (widget: DashboardWidget) => void;
+    /**
+     * Optional Settings handler. Same default-action wiring as
+     * `onWidgetRefresh`.
+     */
+    onWidgetSettings?: (widget: DashboardWidget) => void;
+    /**
+     * Optional Remove handler. When omitted, the default `Remove` action
+     * removes the widget from the layout via `onLayoutChange` (passing
+     * the same array minus the widget — `meta.patch` is empty in that
+     * case so consumers can detect a removal).
+     */
+    onWidgetRemove?: (widget: DashboardWidget) => void;
+}
+/**
+ * Editable variant of `Dashboard` — drag widgets by their header to move
+ * `(x, y)`, drag the bottom-right handle to resize `(w, h)`. Layout snaps
+ * to the underlying CSS grid.
+ *
+ * Implementation notes:
+ *   - Pointer events with `window` listeners (no pointer capture, no
+ *     wheel-blocking, no React state during drag — we only `onLayoutChange`
+ *     when the snapped cell actually changes).
+ *   - Cell width is computed from `gridRef.getBoundingClientRect()` at drag
+ *     start so responsive containers stay accurate between drags.
+ *   - Movement uses `Math.round(delta / cell)` so the widget snaps to the
+ *     nearest cell while the pointer is moving.
+ *   - Per-widget `actions` (the `⋯` menu) and right-click `onWidgetContextMenu`
+ *     work the same way as in the read-only `Dashboard`.
+ */
+declare function DashboardEditor({ widgets, onLayoutChange, columns, rowHeight, gap, editable, unstyled, className, style, onWidgetContextMenu, onDashboardContextMenu, onWidgetRefresh, onWidgetSettings, onWidgetRemove, }: DashboardEditorProps): react_jsx_runtime.JSX.Element;
+
+/** A single bar on the chart. `start` / `end` accept Date or epoch ms. */
+interface GanttTask {
+    /** Stable id (used as React key + `data-task-id`). */
+    id: string;
+    /** Label rendered inside the bar and in the left task list. */
+    name: string;
+    /** Inclusive start of the task. `Date` or epoch milliseconds. */
+    start: Date | number;
+    /** Exclusive end of the task. `Date` or epoch milliseconds. */
+    end: Date | number;
+    /** Completion `0..1`. Renders an inner progress strip when set. */
+    progress?: number;
+    /** Parent task id (for grouping / hierarchy). Reserved for v1+. */
+    parentId?: string;
+    /** Ids of upstream tasks; renders a dependency arrow into this task. */
+    dependencies?: string[];
+    /** Lane id (matches a `GanttResource.id`) — task pinned to that lane. */
+    resourceId?: string;
+    /** Solid fill colour for this bar. Falls back to a token. */
+    color?: string;
+}
+/** A horizontal lane (row) used to group tasks vertically. */
+interface GanttResource {
+    /** Stable id (matched against `GanttTask.resourceId`). */
+    id: string;
+    /** Display label for the left rail. */
+    name: string;
+}
+/** Time-axis granularity. Drives the header ticks AND drag/resize snap step. */
+type GanttScale = 'day' | 'week' | 'month' | 'quarter';
+/** Inclusive `from` / exclusive `to` time window. Both as `Date`. */
+interface GanttRange {
+    from: Date;
+    to: Date;
+}
+interface GanttProps {
+    /** Tasks rendered as bars. Required. */
+    tasks: readonly GanttTask[];
+    /**
+     * Lanes used for vertical grouping. If omitted, every task is rendered in
+     * its own row in the order they appear in `tasks`.
+     */
+    resources?: readonly GanttResource[];
+    /**
+     * Time-axis granularity. Drives header ticks and the drag/resize snap step.
+     * @default 'day'
+     */
+    scale?: GanttScale;
+    /**
+     * Visible time window. If omitted, derived from the `min(start)` /
+     * `max(end)` of all tasks (with one `scale`-step of padding on each side).
+     */
+    range?: GanttRange;
+    /** Row height in pixels. @default 32 */
+    rowHeight?: number;
+    /** Pixel width of one `scale` step (one day, one week, ...). @default 40 */
+    columnWidth?: number;
+    /** Width of the left rail (task / resource list). @default 200 */
+    sidebarWidth?: number;
+    /**
+     * Fires when a task was moved (drag) or resized. The original task object
+     * is left untouched — consumers should patch their state from the returned
+     * task.
+     */
+    onTaskChange?: (task: GanttTask) => void;
+    /** Enables click-and-drag to move bars along the time axis. @default false */
+    draggable?: boolean;
+    /** Enables drag on the right edge of each bar to extend its `end`. @default false */
+    resizable?: boolean;
+    /** Drop default `sg-gantt-*` classes. @default false */
+    unstyled?: boolean;
+    /** Root wrapper className. */
+    className?: string;
+    /** Root wrapper inline style. */
+    style?: CSSProperties;
+}
+
+/**
+ * Gantt chart: tasks-as-bars over a discrete time axis with optional
+ * resource lanes and dependency arrows.
+ *
+ * v1 capabilities:
+ *   - `scale` of `day | week | month | quarter` — drives header ticks AND
+ *     the drag/resize snap step (1 column = 1 step).
+ *   - `draggable` — left-click on a bar moves it horizontally; `start` /
+ *     `end` are emitted via `onTaskChange` once per snap.
+ *   - `resizable` — drag the right edge of a bar to extend `end` only.
+ *   - `dependencies` — orthogonal arrows from upstream task end to dependent
+ *     task start, routed via `routeOrthogonal` from `@skygraph/core`.
+ *   - `resources` — when provided, every task pinned to a lane via
+ *     `resourceId`; otherwise one task per row.
+ *
+ * Out-of-scope (planned for v2): hierarchy collapse, milestones, baselines,
+ * critical-path highlighting, calendar-aware month/quarter widths.
+ */
+declare function Gantt({ tasks, resources, scale, range, rowHeight, columnWidth, sidebarWidth, onTaskChange, draggable, resizable, unstyled, className, style, }: GanttProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Public domain types for `<ResourceCalendar>` — re-shaped from the
+ * `@skygraph/core/calendar` types so the public surface accepts both
+ * `Date` and epoch-`number` for `start` / `end` (mirroring
+ * `<Gantt>`).
+ */
+interface Resource {
+    id: string;
+    name: string;
+    /** Accent colour rendered alongside the resource label. */
+    color?: string;
+    /** Maximum simultaneous assignments tolerated within one slot. */
+    capacityPerSlot?: number;
+    /** Free-form metadata. The component ignores this. */
+    meta?: unknown;
+}
+interface Assignment {
+    id: string;
+    resourceId: string;
+    start: Date | number;
+    end: Date | number;
+    title: string;
+    status?: 'tentative' | 'confirmed' | 'conflict';
+    meta?: unknown;
+}
+
+interface ResourceCalendarProps {
+    /** Resources rendered as horizontal lanes. */
+    resources: readonly Resource[];
+    /** Assignments rendered as positioned blocks. */
+    assignments: readonly Assignment[];
+    /** Optional availability rules — fed to the engine. */
+    rules?: readonly CalendarAvailabilityRule[];
+    /**
+     * Time-axis granularity. Drives header ticks AND drag/resize snap.
+     * @default 'week'
+     */
+    scale?: CalendarScale;
+    /**
+     * Visible time window. If omitted, derived from `min(start)` /
+     * `max(end)` of all assignments with one `scale`-step of padding.
+     */
+    range?: {
+        from: Date;
+        to: Date;
+    };
+    /** Pixel width of one `scale` step. @default 120 */
+    columnWidth?: number;
+    /** Lane / row height in pixels. @default 56 */
+    rowHeight?: number;
+    /** Width of the left rail (resource list). @default 200 */
+    sidebarWidth?: number;
+    /** Enables drag-to-move on assignment blocks. @default false */
+    draggable?: boolean;
+    /** Enables drag on left/right edges of an assignment to resize. @default false */
+    resizable?: boolean;
+    /**
+     * Fires after an assignment was moved or resized. The original
+     * object is left untouched — consumers patch their state from the
+     * returned assignment.
+     */
+    onAssignmentChange?: (next: Assignment) => void;
+    /**
+     * Fires after every internal recompute with the freshly detected
+     * `Conflict[]`. Useful for surfacing badge counts / lists outside
+     * the calendar.
+     */
+    onConflict?: (conflicts: CalendarConflict[]) => void;
+    /** Drop default `sg-rcal-*` classes. @default false */
+    unstyled?: boolean;
+    /** Root wrapper className. */
+    className?: string;
+    /** Root wrapper inline style. */
+    style?: CSSProperties;
+}
+
+/**
+ * Resource Calendar — shifts / bookings per resource lane with
+ * automatic conflict detection.
+ *
+ * v1 capabilities:
+ *   - `scale` of `day | week | month` — drives header ticks AND
+ *     drag/resize snap (1 column = 1 step).
+ *   - `draggable` — drag a block to move it horizontally; both `start`
+ *     and `end` shift by the snapped delta. Lane (resource) is
+ *     preserved — vertical lane changes are out of scope for v1.
+ *   - `resizable` — drag the left/right edge to resize that side
+ *     independently. Minimum width clamped to one `scale` step.
+ *   - Conflict overlay — assignments participating in any conflict
+ *     get the `sg-rcal-assignment-conflict` modifier (red border /
+ *     hatched background). `onConflict` fires after every change with
+ *     the freshly detected `Conflict[]`.
+ *   - `availability-off` background bands appear on slots that fall
+ *     outside the configured `rules`.
+ *
+ * Out-of-scope (planned for v2): cross-lane drag, multi-day all-day
+ * blocks, recurrence, exception dates, calendar-aware month widths.
+ */
+declare function ResourceCalendar({ resources, assignments, rules, scale, range, columnWidth, rowHeight, sidebarWidth, draggable, resizable, onAssignmentChange, onConflict, unstyled, className, style, }: ResourceCalendarProps): react_jsx_runtime.JSX.Element;
+
+/** A single event placed on the timeline at a specific date. */
+interface TimelineEvent {
+    /** Stable id (used as React key + `data-event-id`). */
+    id: string;
+    /** Event date — `Date` or epoch ms. Drives positioning AND grouping. */
+    date: Date | number;
+    /** Marker title (typically a short heading). */
+    title: ReactNode;
+    /** Optional secondary description. Rendered below the title. */
+    description?: ReactNode;
+    /** Optional dot fill colour. */
+    color?: string;
+}
+/** Visual orientation of the timeline track. */
+type TimelineOrientation = 'horizontal' | 'vertical';
+/** Bucket boundary for the optional `groupBy` divider. */
+type TimelineGroupBy = 'day' | 'month' | 'year';
+interface EventTimelineProps {
+    /** Events to render. */
+    events: readonly TimelineEvent[];
+    /**
+     * Track orientation. Horizontal renders left-to-right with markers above
+     * a baseline; vertical renders top-to-bottom (a la VCS commit list).
+     * @default 'vertical'
+     */
+    orientation?: TimelineOrientation;
+    /**
+     * Group consecutive events sharing the same `day` / `month` / `year`
+     * bucket and render a divider between groups. Bucket boundary uses UTC.
+     */
+    groupBy?: TimelineGroupBy;
+    /**
+     * Custom marker renderer. Receives the event and should return the dot
+     * (or any shape) to render in place of the default circle.
+     */
+    renderMarker?: (event: TimelineEvent) => ReactNode;
+    /**
+     * Custom event-content renderer. Receives the event and replaces the
+     * default `title` + `description` block.
+     */
+    renderEvent?: (event: TimelineEvent) => ReactNode;
+    /** Drop default `sg-event-timeline-*` classes. @default false */
+    unstyled?: boolean;
+    /** Root wrapper className. */
+    className?: string;
+    /** Root wrapper inline style. */
+    style?: CSSProperties;
+}
+
+/**
+ * Event-driven timeline: renders a sorted list of `TimelineEvent`s with an
+ * optional grouping divider (`day | month | year`) and a horizontal /
+ * vertical orientation.
+ *
+ * Distinct from `Timeline` (the simpler step-based UI primitive in
+ * `components/ui/Timeline.tsx`) — this one is for chronological event
+ * streams where each item has a `Date`.
+ */
+declare function EventTimeline({ events, orientation, groupBy, renderMarker, renderEvent, unstyled, className, style, }: EventTimelineProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Контекст, передаваемый в `onClick` каждой `ChartAction`. Содержит ссылку
+ * на корневой `<svg>` чарта, опциональное имя файла для экспортов и
+ * утилиты сброса brush / переключения легенды (если эти сценарии включены
+ * вызывающей стороной).
+ */
+interface ChartActionContext {
+    /** Корневой SVG-элемент текущего чарта. */
+    svg: SVGSVGElement;
+    /** Базовое имя файла без расширения (используется print / SVG / PNG). */
+    fileName?: string;
+    /** Сбросить активный brush — определён только если у чарта `brush` включён. */
+    brushReset?: () => void;
+    /** Переключить отображение легенды — userland-сценарий, не определён по умолчанию. */
+    toggleLegend?: () => void;
+}
+/**
+ * Декларативное описание одной кнопки в hover-toolbar чарта. UI-аватар
+ * (`icon`) — любой `ReactNode` (обычно inline-SVG 16×16 stroke 1.5).
+ */
+interface ChartAction {
+    /** Уникальный id (попадает в `data-sg-action`). */
+    id: string;
+    /** Иконка кнопки (рекомендуется inline SVG 16×16, stroke 1.5). */
+    icon: ReactNode;
+    /** Текст для `aria-label` / `title`. */
+    label: string;
+    /** Обработчик клика. Получает контекст с SVG-ссылкой. */
+    onClick: (ctx: ChartActionContext) => void;
+    /** Скрыть кнопку (но оставить в массиве — для условной логики). */
+    hidden?: boolean;
+}
+/**
+ * Допустимые значения prop-а `actions`:
+ * - `false` / `undefined` — toolbar не рендерится.
+ * - `true` — рендерится дефолтный набор (print + SVG + PNG + reset brush, если включён).
+ * - массив `ChartAction[]` — кастомный набор.
+ */
+type ChartActionsProp = boolean | readonly ChartAction[];
+/**
+ * Возвращает дефолтный набор `ChartAction`-ов для toolbar-а. Используется
+ * чартами, когда `actions=true` (sugar-форма).
+ */
+declare function defaultChartActions(opts: {
+    /** Передаётся в `printElement` как `fileName`. */
+    fileName?: string;
+    /** Если задан — добавляется кнопка `resetBrush`. */
+    brushReset?: () => void;
+}): ChartAction[];
+interface ChartHoverToolbarProps {
+    /** Видимая ли панель сейчас (родитель прокидывает по hover/focus). */
+    visible: boolean;
+    /** Список кнопок. */
+    actions: readonly ChartAction[];
+    /** Базовое имя файла для экспортов / print. */
+    fileName?: string;
+    /** Возвращает текущий SVG-элемент чарта (на момент клика). */
+    getSvg: () => SVGSVGElement | null;
+    /** Сбросить brush (если в чарте он есть). */
+    brushReset?: () => void;
+    /** Переключить легенду — userland решает. */
+    toggleLegend?: () => void;
+    /** Сбросить дефолтные классы `.sg-chart-toolbar*` — headless-режим. */
+    unstyled?: boolean;
+    /** Опциональный `className` для контейнера. */
+    className?: string;
+    /** Опциональный inline-style на контейнере. */
+    style?: CSSProperties;
+}
+/**
+ * Floating-панель действий, плавающая поверх чарта в правом верхнем углу.
+ *
+ * Появляется на hover/focus родителя — родитель сам управляет prop-ом
+ * `visible` (через `data-sg-toolbar="visible|hidden"`). CSS-анимация
+ * `opacity 180ms` живёт в `charts.css`. Сама обёртка имеет `pointer-events:
+ * none`, кнопки — `pointer-events: auto`, чтобы не перехватывать события
+ * crosshair / brush на пустом overlay.
+ */
+declare function ChartHoverToolbar({ visible, actions, fileName, getSvg, brushReset, toggleLegend, unstyled, className, style, }: ChartHoverToolbarProps): react_jsx_runtime.JSX.Element | null;
+/**
+ * Резолвит prop `actions` (boolean | array) в актуальный массив с учётом
+ * дефолтных кнопок и опциональной кнопки `resetBrush`. Возвращает `null`,
+ * если toolbar в принципе не должен рендериться.
+ */
+declare function resolveChartActions(actions: ChartActionsProp | undefined, opts: {
+    fileName?: string;
+    brushReset?: () => void;
+}): readonly ChartAction[] | null;
+
+/**
+ * Payload для контекстного меню по серии / отдельной точке. Отдаётся в
+ * `onSeriesContextMenu` ровно тогда, когда пользователь правой кнопкой
+ * кликнул по визуальному элементу серии (line-segment, marker, bar, slice,
+ * area-path).
+ */
+interface ChartSeriesContextMenuPayload {
+    /** `id` исходного `ChartSeries` или `PieChartSlice`. */
+    seriesId: string;
+    /** Индекс серии в массиве `series` (0-based). Для Pie — индекс slice-а. */
+    seriesIndex: number;
+    /** Индекс категории по X (0-based). Не определён для chart-уровня pie. */
+    valueIndex?: number;
+    /** Числовое значение в этой точке (если применимо). */
+    value?: number;
+}
+/**
+ * Payload для контекстного меню по чарту в целом (клик правой кнопкой по
+ * пустому месту плот-области, осям, сетке).
+ */
+interface ChartContextMenuPayload {
+    /** X в CSS-пикселях относительно SVG. */
+    x: number;
+    /** Y в CSS-пикселях относительно SVG. */
+    y: number;
+    /** X в координатах SVG user-space (то же, что и x для не-stretch SVG). */
+    plotX: number;
+    /** Y в координатах SVG user-space. */
+    plotY: number;
+}
+/** Сигнатура коллбэка `onSeriesContextMenu`. */
+type ChartSeriesContextMenuHandler = (event: MouseEvent, payload: ChartSeriesContextMenuPayload) => void;
+/** Сигнатура коллбэка `onChartContextMenu`. */
+type ChartContextMenuHandler = (event: MouseEvent, payload: ChartContextMenuPayload) => void;
+/**
+ * Создаёт `onContextMenu`-обработчик для visual-элемента серии (line-
+ * segment / marker / bar / area-path / pie-slice).
+ *
+ * - Если `handler` не задан — возвращает `undefined` (нативный browser
+ *   menu остаётся валидным).
+ * - Иначе вызывает `event.preventDefault()` + `event.stopPropagation()`,
+ *   чтобы chart-уровневый handler не сработал и не открылось браузерное
+ *   меню.
+ */
+declare function makeSeriesContextMenuHandler(handler: ChartSeriesContextMenuHandler | undefined, payload: ChartSeriesContextMenuPayload): ((e: MouseEvent) => void) | undefined;
+/**
+ * Создаёт `onContextMenu`-обработчик для SVG-корня (chart-уровень). Если
+ * не задан — возвращает `undefined`, чтобы НЕ блокировать дефолтное
+ * браузерное меню.
+ */
+declare function makeChartContextMenuHandler(handler: ChartContextMenuHandler | undefined): ((e: MouseEvent<SVGSVGElement>) => void) | undefined;
+
+/** A single category along the X axis. */
+type ChartCategory = string | number;
+/** Numeric value for a series at a specific category. */
+type ChartValue = number | null;
+/** One series — a logical line / bar / pie slice with a label and values. */
+interface ChartSeries {
+    /** Unique identifier (used for keying React lists and color resolution). */
+    id: string;
+    /** Human-readable label used in legend / tooltip. */
+    label: string;
+    /** Optional explicit colour (CSS value). Defaults to a deterministic palette by index. */
+    color?: string;
+    /**
+     * Per-category values. Index N corresponds to `categories[N]`.
+     * Use `null` to mark a gap (line will be split, bar will be hidden).
+     */
+    values: readonly ChartValue[];
+}
+/**
+ * X axis configuration. Off by default — when `xAxis` is omitted no axis
+ * elements are rendered (backward-compat with v0).
+ */
+interface XAxisOptions {
+    /**
+     * Number of category ticks to render. If omitted or larger than the number
+     * of categories, every category is labelled. Otherwise N evenly-spaced
+     * categories are picked (always including the first and last).
+     */
+    tickCount?: number;
+    /** Format the visible category label. Default: `String(category)`. */
+    tickFormatter?: (category: ChartCategory, index: number) => string;
+    /** Optional axis title rendered below the plot. */
+    label?: string;
+}
+/**
+ * Y axis configuration. Off by default — when `yAxis` is omitted no axis
+ * elements are rendered (backward-compat with v0).
+ */
+interface YAxisOptions {
+    /** Number of evenly-spaced ticks (including endpoints). @default 5 */
+    tickCount?: number;
+    /** Format the visible numeric tick label. Default: short numeric. */
+    tickFormatter?: (value: number) => string;
+    /** Optional axis title rendered to the left of the plot (rotated). */
+    label?: string;
+    /** Render horizontal gridlines at each tick. @default false */
+    gridLines?: boolean;
+}
+/**
+ * Animation configuration for chart mount / data transitions.
+ *
+ * - `true` / omitted — enable with default duration (600ms).
+ * - `false` — disable entirely (no animation classes / styles applied).
+ * - `{ duration: ms }` — explicit duration in milliseconds.
+ *
+ * Implementation is pure CSS (no `requestAnimationFrame` loops): we pass the
+ * duration as a `--sg-chart-anim-duration` custom property on the animated
+ * elements and let `@keyframes` in `charts.css` handle the timing.
+ */
+type ChartAnimation = boolean | {
+    duration?: number;
+};
+/** Default animation duration in milliseconds (when `animate` is not given a number). */
+declare const DEFAULT_CHART_ANIMATION_MS = 600;
+/** Resolves a `ChartAnimation` value into a normalized `{ enabled, duration }` shape. */
+declare function resolveChartAnimation(animate: ChartAnimation | undefined): {
+    enabled: boolean;
+    duration: number;
+};
+/**
+ * Builds a stable string key from a list of values that re-mounts animated
+ * subtrees only when the data really changes (categories / series). Used as
+ * `key={...}` on animated `<g>` groups so CSS animations re-trigger on data
+ * updates, not on every render.
+ */
+declare function chartDataKey(parts: readonly unknown[]): string;
+/** Common shape for chart props. */
+interface BaseChartProps {
+    /** Categories along the X axis. */
+    categories: readonly ChartCategory[];
+    /** One or more data series. */
+    series: readonly ChartSeries[];
+    /** Width of the chart in CSS units. Defaults to `'100%'`. */
+    width?: number | string;
+    /** Height of the chart in pixels. Defaults to `200`. */
+    height?: number;
+    /** Optional class name on the root SVG. */
+    className?: string;
+    /** Optional inline style on the root SVG. */
+    style?: CSSProperties;
+    /** Drop default `sg-chart-*` classes (headless mode). */
+    unstyled?: boolean;
+    /** Padding around the plot area in pixels (number or [top, right, bottom, left]). */
+    padding?: number | readonly [number, number, number, number];
+    /** Show a small horizontal legend below the SVG. @default false */
+    legend?: boolean;
+    /**
+     * Mount / data-change animation toggle. Pure CSS, no rAF loops.
+     * @default true
+     */
+    animate?: ChartAnimation;
+    /**
+     * Optional X axis configuration. When omitted, no x-axis is rendered
+     * (v0 backward-compat). When provided, ticks / labels / optional title
+     * are drawn inside the SVG via `<ChartAxes>`.
+     */
+    xAxis?: XAxisOptions;
+    /**
+     * Optional Y axis configuration. When omitted, no y-axis is rendered.
+     * Set `gridLines: true` to draw horizontal grid lines across the plot.
+     */
+    yAxis?: YAxisOptions;
+    /**
+     * Включает поддержку `ref.print()`. Сама печать триггерится императивно
+     * через ref. `{ fileName }` задаёт имя popup-окна.
+     * @default false
+     */
+    printable?: PrintableProp;
+    /**
+     * Hover-toolbar в правом верхнем углу чарта с действиями (print, export
+     * SVG/PNG, сброс brush). `true` — дефолтный набор; `ChartAction[]` —
+     * кастомный. По умолчанию выключено.
+     */
+    actions?: ChartActionsProp;
+    /**
+     * Базовое имя файла без расширения для экспортов SVG / PNG / print.
+     * @default 'chart'
+     */
+    fileName?: string;
+    /**
+     * Контекстное меню (правая кнопка) по элементу серии: line-segment,
+     * marker, bar, area-path. Если задано — браузерное меню блокируется
+     * `event.preventDefault()`.
+     */
+    onSeriesContextMenu?: ChartSeriesContextMenuHandler;
+    /**
+     * Контекстное меню (правая кнопка) по плот-области чарта (вне серий).
+     * Если задано — браузерное меню блокируется `event.preventDefault()`.
+     */
+    onChartContextMenu?: ChartContextMenuHandler;
+}
+/** Default colour palette — uses tokens so charts re-theme without code changes. */
+declare const DEFAULT_PALETTE: readonly ["var(--sg-color-primary)", "var(--sg-color-success)", "var(--sg-color-warning)", "var(--sg-color-error)", "var(--sg-blue-4)", "var(--sg-orange-5)", "var(--sg-green-5)", "var(--sg-red-5)"];
+declare function colorForSeries(series: ChartSeries, index: number): string;
+
+interface ChartLegendProps {
+    series: readonly ChartSeries[];
+    className?: string;
+    style?: CSSProperties;
+}
+/**
+ * Minimal horizontal legend for charts. Renders below the SVG with one
+ * `<span>` per series (colored swatch + label).
+ */
+declare function ChartLegend({ series, className, style }: ChartLegendProps): react_jsx_runtime.JSX.Element;
+
+/** Imperative API общая для LineChart / BarChart / AreaChart / PieChart. */
+interface ChartRef {
+    /**
+     * Открыть popup и вызвать window.print() для DOM-области графика.
+     * `customStyles` / `pageSize` / `orientation` мерджатся с тем, что задано
+     * в prop `printable`.
+     */
+    print: (opts?: PrintOptions) => void;
+}
+
+/** One labelled value to display in the crosshair tooltip column. */
+interface ChartCrosshairPoint {
+    /** Series label (matches `ChartSeries.label`). */
+    label: string;
+    /** Numeric value at the hovered category. */
+    value: number;
+    /** Resolved series colour (CSS value). */
+    color: string;
+    /** Y coordinate (in plot user-space) for the dot marker. */
+    y: number;
+}
+interface ChartCrosshairProps {
+    /** X coordinate of the vertical line (plot user-space). */
+    x: number;
+    /** Top-left X of the plot area (used for tooltip horizontal clamping). */
+    plotX: number;
+    /** Top-left Y of the plot area (top of the vertical line). */
+    plotY: number;
+    /** Plot height (length of the vertical line). */
+    plotH: number;
+    /** Plot width (used for tooltip clamping). */
+    plotW: number;
+    /** Hovered category — shown as the tooltip header. */
+    category: ChartCategory;
+    /** Per-series snapshot of value + dot position at the hovered X. */
+    points: readonly ChartCrosshairPoint[];
+    /** Drop the default `sg-chart-crosshair-*` class names. */
+    unstyled?: boolean;
+    /** Optional formatter for numeric values shown in the tooltip. */
+    valueFormatter?: (value: number) => string;
+}
+/**
+ * Shared SVG overlay for chart crosshair / hover tooltip.
+ *
+ * Renders a vertical guide line at `x`, a small dot for each non-null series
+ * value at the hovered category, and a tooltip card listing the values. The
+ * tooltip flips to the left of the line when there is not enough space on the
+ * right inside `[plotX, plotX + plotW]`.
+ *
+ * Pure presentational: no state, no listeners — the parent chart owns the
+ * mouse logic and decides when to render this component.
+ */
+declare function ChartCrosshair({ x, plotX, plotY, plotH, plotW, category, points, unstyled, valueFormatter, }: ChartCrosshairProps): react_jsx_runtime.JSX.Element;
+
+/** Диапазон выделения, выраженный в индексах категорий (включительно). */
+interface ChartBrushRange {
+    /** Стартовый индекс. Всегда `<= to`. */
+    from: number;
+    /** Конечный индекс. Всегда `>= from`. */
+    to: number;
+}
+/**
+ * Конфиг brushing-prop, который чарты пробрасывают в общий `<ChartBrush>`.
+ * Принимает либо `boolean` (включить uncontrolled), либо объект.
+ */
+interface ChartBrushConfig {
+    /** Контролируемый диапазон. `null` — диапазон не выбран. */
+    range?: ChartBrushRange | null;
+    /** Стартовый диапазон в uncontrolled-режиме. */
+    defaultRange?: ChartBrushRange | null;
+    /**
+     * Срабатывает на `pointerup` после drag и на `dblclick` (reset → `null`).
+     * `from`/`to` — индексы категорий (целочисленные, `from <= to`).
+     */
+    onRangeChange?: (range: ChartBrushRange | null) => void;
+    /** Цвет заливки выделения. Дефолт — `var(--sg-color-primary)` с прозрачностью. */
+    fill?: string;
+    /** Заблокировать создание / изменение brush — но контролируемый диапазон всё равно отрисуется. */
+    disabled?: boolean;
+}
+/** Резолвит `brush` prop в `ChartBrushConfig | null`. */
+declare function resolveBrushConfig(brush: boolean | ChartBrushConfig | undefined): ChartBrushConfig | null;
+interface ChartBrushProps {
+    /** Левая граница plot-области в SVG user-space. */
+    plotX: number;
+    /** Верхняя граница plot-области в SVG user-space. */
+    plotY: number;
+    /** Ширина plot-области. */
+    plotW: number;
+    /** Высота plot-области. */
+    plotH: number;
+    /** Количество категорий по X. Используется для маппинга x → index. */
+    categoryCount: number;
+    /** Текущий диапазон выделения (контролируемый). `null` — не выделено. */
+    range: ChartBrushRange | null;
+    /** Срабатывает при каждом завершении выделения / reset. */
+    onRangeChange: (range: ChartBrushRange | null) => void;
+    /** Сбрасывает default-классы `.sg-chart-brush-*`. */
+    unstyled?: boolean;
+    /** Цвет заливки. */
+    fill?: string;
+    /** Полностью выключает интерактив, оставляя только визуал. */
+    disabled?: boolean;
+}
+/**
+ * Brushing overlay: drag по plot-области → диапазон в `[from, to]` индексах
+ * категорий. Двойной клик сбрасывает диапазон в `null`.
+ *
+ * Презентационный компонент: владеет временным dragging-state, но финальный
+ * диапазон публикует через `onRangeChange`. Контролируемый `range` приходит
+ * сверху и определяет, что отрисовать.
+ */
+declare function ChartBrush({ plotX, plotY, plotW, plotH, categoryCount, range, onRangeChange, unstyled, fill, disabled, }: ChartBrushProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Crosshair behaviour toggle for {@link LineChart}. When `true`, a vertical
+ * guide line + per-series tooltip appears on hover.
+ */
+type LineChartCrosshair = boolean | {
+    /** Custom formatter for tooltip numeric values. */
+    valueFormatter?: (value: number) => string;
+};
+interface LineChartProps extends BaseChartProps {
+    /** Show small dot markers at each data point. @default true */
+    markers?: boolean;
+    /** Stroke width in pixels. @default 2 */
+    strokeWidth?: number;
+    /**
+     * Hover crosshair with a vertical guide line and per-series value tooltip.
+     * @default false
+     */
+    crosshair?: LineChartCrosshair;
+    /**
+     * Brush для drag-выбора диапазона по X. `true` — uncontrolled с пустым
+     * стартовым значением; объект — `ChartBrushConfig`. См. `ChartBrush`.
+     */
+    brush?: boolean | ChartBrushConfig;
+}
+declare const LineChart: React$1.ForwardRefExoticComponent<LineChartProps & React$1.RefAttributes<ChartRef>>;
+
+interface BarChartProps extends BaseChartProps {
+    /** Gap between groups in [0..1] of category step. @default 0.2 */
+    groupGap?: number;
+    /** Gap between bars within a group in [0..1] of bar slot. @default 0.1 */
+    barGap?: number;
+    /**
+     * Brush для drag-выбора диапазона по X. `true` — uncontrolled с пустым
+     * стартовым значением; объект — `ChartBrushConfig`. См. `ChartBrush`.
+     */
+    brush?: boolean | ChartBrushConfig;
+}
+declare const BarChart: React$1.ForwardRefExoticComponent<BarChartProps & React$1.RefAttributes<ChartRef>>;
+
+interface AreaChartProps extends BaseChartProps {
+    /** Stack series on top of each other (cumulative). @default false */
+    stacked?: boolean;
+    /** Stroke width on the top edge. @default 2 */
+    strokeWidth?: number;
+    /** Fill opacity (0..1). @default 0.25 */
+    fillOpacity?: number;
+    /**
+     * Brush для drag-выбора диапазона по X. `true` — uncontrolled с пустым
+     * стартовым значением; объект — `ChartBrushConfig`. См. `ChartBrush`.
+     */
+    brush?: boolean | ChartBrushConfig;
+}
+declare const AreaChart: React$1.ForwardRefExoticComponent<AreaChartProps & React$1.RefAttributes<ChartRef>>;
+
+interface PieChartSlice {
+    /** Stable id for keying / legend. */
+    id: string;
+    /** Display label (legend / accessible description). */
+    label: string;
+    /** Numeric value. Negative values are clamped to 0. */
+    value: number;
+    /** Optional explicit fill colour. Falls back to default palette by index. */
+    color?: string;
+}
+interface PieChartProps {
+    data: readonly PieChartSlice[];
+    /** SVG width. */
+    width?: number | string;
+    /** SVG height. */
+    height?: number | string;
+    /** Inner radius (donut). 0 → solid pie. @default 0 */
+    innerRadius?: number;
+    /** Outer radius. @default 80 */
+    outerRadius?: number;
+    /** Drop default sg-chart classes. */
+    unstyled?: boolean;
+    className?: string;
+    style?: CSSProperties;
+    /**
+     * Mount / data-change animation toggle. When enabled, slices fade-in and
+     * rotate from `-90deg` to `0deg` around the pie centre.
+     * @default true
+     */
+    animate?: ChartAnimation;
+    /**
+     * Включает поддержку `ref.print()`. `{ fileName }` — имя popup-окна.
+     * @default false
+     */
+    printable?: PrintableProp;
+    /**
+     * Hover-toolbar в правом верхнем углу — print + SVG + PNG.
+     */
+    actions?: ChartActionsProp;
+    /** Базовое имя файла для экспортов. @default 'chart' */
+    fileName?: string;
+    /**
+     * Контекстное меню по slice-у (правая кнопка). Payload содержит
+     * `seriesId` (равен `slice.id`), `seriesIndex` и `value`.
+     */
+    onSeriesContextMenu?: ChartSeriesContextMenuHandler;
+    /** Контекстное меню по фону pie chart (вне slice-ов). */
+    onChartContextMenu?: ChartContextMenuHandler;
+}
+declare const PieChart: React$1.ForwardRefExoticComponent<PieChartProps & React$1.RefAttributes<ChartRef>>;
+
+/** Измеренный размер контейнера / SVG-элемента в пикселях. */
+interface ChartSize {
+    /** Целочисленная ширина контейнера в CSS-пикселях. */
+    width: number;
+    /** Целочисленная высота контейнера в CSS-пикселях. */
+    height: number;
+}
+/**
+ * Хук, отслеживающий реальный размер DOM-элемента через `ResizeObserver`.
+ *
+ * Возвращает `{ width, height }` в CSS-пикселях. До первого срабатывания
+ * RO (или в окружениях без `ResizeObserver` — SSR / jsdom) отдаёт
+ * `fallback`. Это безопасно для рендера до mount-а: чарты используют
+ * fallback-размеры (как правило, дефолтные `600 × height`-prop), а после
+ * mount-а — пересчитываются по реальному размеру контейнера.
+ *
+ * Округление результата исключает суб-пиксельные дёрганья при resize-loop
+ * (один пиксель туда-сюда из-за zoom / scrollbar).
+ *
+ * Не реагирует на смену самого `ref` (наблюдает только текущий
+ * `ref.current`); в SkyGraph-чартах ref стабилен на всю жизнь компонента,
+ * поэтому это ok.
+ */
+declare function useChartSize<T extends Element>(ref: React.RefObject<T | null>, fallback: ChartSize): ChartSize;
+
+/**
+ * Экспорт SVG-чарта в файл (SVG / PNG) — без runtime-зависимостей.
+ *
+ * Используем штатный `XMLSerializer` + `URL.createObjectURL` + `Image` +
+ * `<canvas>.toBlob`; выгрузка через невидимый `<a download>`. Никакого
+ * `dom-to-image` / `html2canvas` / `canvg` — браузер сам всё умеет.
+ */
+/** Размер выгружаемого PNG в CSS-пикселях. */
+interface PngSize {
+    /** Ширина PNG в CSS-пикселях. */
+    width: number;
+    /** Высота PNG в CSS-пикселях. */
+    height: number;
+}
+/** Параметры PNG-экспорта. */
+interface DownloadPngOptions {
+    /** Имя файла без расширения / с `.png`. По умолчанию `chart.png`. */
+    fileName?: string;
+    /**
+     * Множитель плотности пикселей. По умолчанию `window.devicePixelRatio`
+     * (или `2` если `window` нет). Файл получает `width × scale` пикселей,
+     * но визуально — нормальные `width` CSS-пикселей.
+     */
+    scale?: number;
+    /** Цвет фона. По умолчанию `transparent` — экспорт с прозрачным фоном. */
+    background?: string;
+}
+/**
+ * Сериализует `<svg>` в строку с inline `width` / `height` и явными
+ * пространствами имён. Принимает оригинальный элемент — не модифицирует
+ * его (работаем с глубокой копией).
+ */
+declare function serializeSvg(svg: SVGSVGElement, size?: PngSize): string;
+/** Триггерит загрузку blob-а под именем `fileName` через невидимый `<a>`. */
+declare function triggerDownload(blob: Blob, fileName: string): void;
+/** Измеряет рабочий размер SVG: real DOM size → viewBox → fallback. */
+declare function measureSvg(svg: SVGSVGElement): PngSize;
+/**
+ * Скачивает текущий SVG-чарт как `.svg`-файл с явными `width` / `height`,
+ * чтобы файл нормально открывался в любом просмотрщике.
+ */
+declare function downloadSvg(svg: SVGSVGElement, fileName?: string): void;
+/**
+ * Конвертирует SVG-чарт в PNG через штатный browser-canvas и скачивает
+ * результат. Возвращает `Promise<void>`, который резолвится после клика
+ * `<a download>` или реджектится при сбое декодирования SVG.
+ *
+ * Стратегия:
+ *   1. Сериализуем SVG → object-URL.
+ *   2. Грузим в `Image` (браузер сам декодирует SVG как растр).
+ *   3. Рисуем на `<canvas>` с devicePixelRatio-масштабом → `.toBlob('image/png')`.
+ *   4. Триггерим скачивание через `<a download>`.
+ *
+ * Альтернатива — `OffscreenCanvas`. Не используем: поддержка хуже, в
+ * Safari < 17 нет, для маленьких чартов выигрыша нет. См. отчёт раунда.
+ */
+declare function downloadSvgAsPng(svg: SVGSVGElement, fileNameOrOpts?: string | DownloadPngOptions): Promise<void>;
+
+/**
+ * Имена слотов `List`. Полный список и описания — `docs/styling-contract.md` §4.2.
+ */
+type ListSlot = 'root' | 'header' | 'footer' | 'items' | 'item' | 'empty' | 'pagination';
+type ListClassNames = SlotClassNames<ListSlot>;
+type ListStyles = SlotStyles<ListSlot>;
+/** Props for a generic list with optional pagination, grid layout, and loading state. */
+interface ListProps<T = any> {
+    /** Items to render. */
+    dataSource: T[];
+    /** Renders one item; `index` reflects order in the current page when paginated. */
+    renderItem: (item: T, index: number) => React__default.ReactNode;
+    /** Content above the list body. */
+    header?: React__default.ReactNode;
+    /** Content below the list body. */
+    footer?: React__default.ReactNode;
+    /**
+     * Wraps the list in a loading state.
+     * @default false
+     */
+    loading?: boolean;
+    /** "Load more" action area below items. */
+    loadMore?: React__default.ReactNode;
+    /** Client pagination config, or `false` to disable. */
+    pagination?: false | {
+        /** Current page (controlled). */
+        current?: number;
+        /** Items per page. */
+        pageSize?: number;
+        /** Total items for the pager; defaults to `dataSource.length`. */
+        total?: number;
+        /** Fired when the page changes. */
+        onChange?: (page: number, pageSize: number) => void;
+    };
+    /** CSS grid layout for items. */
+    grid?: {
+        /** Gap between grid cells in pixels. */
+        gutter?: number;
+        /** Column count in the grid. */
+        column?: number;
+        /** Columns at extra-small breakpoint. */
+        xs?: number;
+        /** Columns at small breakpoint. */
+        sm?: number;
+        /** Columns at medium breakpoint. */
+        md?: number;
+        /** Columns at large breakpoint. */
+        lg?: number;
+    };
+    /**
+     * List density preset.
+     * @default 'default'
+     */
+    size?: 'small' | 'default' | 'large';
+    /**
+     * Shows dividers between items when `true`.
+     * @default true
+     */
+    split?: boolean;
+    /**
+     * Outlines the list container when `true`.
+     * @default false
+     */
+    bordered?: boolean;
+    /** Localized strings for the list chrome. */
+    locale?: {
+        /** Message when `dataSource` is empty. */
+        emptyText?: React__default.ReactNode;
+    };
+    /** Root class name. */
+    className?: string;
+    /** Root inline styles. */
+    style?: React__default.CSSProperties;
+    /** Renders without Skygraph list styles. */
+    unstyled?: boolean;
+    /** Virtualizes rendering for large lists. Fixed item height required. */
+    virtual?: {
+        /** Fixed item height in pixels. */
+        itemHeight: number;
+        /** Fixed container height in pixels. */
+        height: number;
+        /** Extra items above/below viewport. @default 5 */
+        overscan?: number;
+    };
+    /** Enables click-to-select items. */
+    selectable?: boolean;
+    /** Controlled selected item indices. */
+    selectedKeys?: number[];
+    /** Default selected indices. */
+    defaultSelectedKeys?: number[];
+    /** Fires when selection changes. */
+    onSelectionChange?: (keys: number[], items: T[]) => void;
+    /** Multi-select (hold Ctrl/Cmd). @default false */
+    multiSelect?: boolean;
+    /** Enables drag-and-drop reorder. */
+    draggable?: boolean;
+    /** Fires after items are reordered via drag. */
+    onReorder?: (fromIndex: number, toIndex: number) => void;
+    /** Row hover highlight. @default true */
+    hoverable?: boolean;
+    /** Row click handler. */
+    onItemClick?: (item: T, index: number) => void;
+    /** Row class name (static or per-item). */
+    rowClassName?: string | ((item: T, index: number) => string);
+    /** Публичные классы по слотам. См. `docs/styling-contract.md` §4.2. */
+    classNames?: ListClassNames;
+    /** Публичные стили по слотам. См. `docs/styling-contract.md` §4.2. */
+    styles?: ListStyles;
+}
+/** Props for `List.Item` row layout. */
+interface ListItemProps {
+    /** Main cell content. */
+    children?: React__default.ReactNode;
+    /** Inline actions rendered after the main content. */
+    actions?: React__default.ReactNode[];
+    /** Secondary column aligned to the end of the row. */
+    extra?: React__default.ReactNode;
+    /** Class name on the item root. */
+    className?: string;
+    /** Inline styles on the item root. */
+    style?: React__default.CSSProperties;
+}
+/** Props for `List.Item.Meta` avatar/title/description block. */
+interface ListItemMetaProps {
+    /** Leading visual (e.g. avatar). */
+    avatar?: React__default.ReactNode;
+    /** Primary line. */
+    title?: React__default.ReactNode;
+    /** Secondary line under the title. */
+    description?: React__default.ReactNode;
+}
+
+declare function ListItemMeta({ avatar, title, description }: ListItemMetaProps): react_jsx_runtime.JSX.Element;
+declare function ListItemComponent({ children, actions, extra, className, style }: ListItemProps): react_jsx_runtime.JSX.Element;
+type ListItemType = typeof ListItemComponent & {
+    Meta: typeof ListItemMeta;
+};
+declare function ListInner<T = any>({ dataSource, renderItem, header, footer, loading, loadMore, pagination, grid, size, split, bordered, locale, className, style, unstyled, virtual, selectable, selectedKeys: controlledSelectedKeys, defaultSelectedKeys, onSelectionChange, multiSelect, draggable, onReorder, hoverable, onItemClick, rowClassName, classNames: slotCls, styles: slotSty, }: ListProps<T>): react_jsx_runtime.JSX.Element;
+type ListType = typeof ListInner & {
+    Item: ListItemType;
+};
+/**
+ * Renders a vertical or grid list with optional header, footer, pagination, loading,
+ * virtual scroll, selection, and drag-and-drop reorder.
+ * Use `List.Item` and `List.Item.Meta` for structured rows.
+ */
+declare const List: ListType;
+
+/** One row in a transfer list. */
+interface TransferItem {
+    /** Stable unique key. */
+    key: string;
+    /** Primary label text. */
+    title: string;
+    /** Secondary description line. */
+    description?: string;
+    /** Disables selection and move for this item. */
+    disabled?: boolean;
+}
+/** Props for the `Transfer` shuttle component. */
+interface TransferProps {
+    /** Full item list; membership in `targetKeys` determines the right column. */
+    dataSource: TransferItem[];
+    /** Keys currently placed in the target (right) list. */
+    targetKeys: string[];
+    /** Fires after items move left or right. */
+    onChange?: (targetKeys: string[], direction: 'left' | 'right', moveKeys: string[]) => void;
+    /** Controlled selected keys in both lists combined. */
+    selectedKeys?: string[];
+    /** Fires when selection changes in either list. */
+    onSelectChange?: (sourceSelectedKeys: string[], targetSelectedKeys: string[]) => void;
+    /** Titles for source and target column headers. */
+    titles?: [React__default.ReactNode, React__default.ReactNode];
+    /** Custom render for a list row body. */
+    render?: (item: TransferItem) => React__default.ReactNode;
+    /** @default false */
+    showSearch?: boolean;
+    /** Predicate for search filtering; defaults to title substring match. */
+    filterOption?: (inputValue: string, item: TransferItem) => boolean;
+    /** Search input placeholder override. */
+    searchPlaceholder?: string;
+    /** @default true */
+    showSelectAll?: boolean;
+    /** @default false */
+    disabled?: boolean;
+    /** When true, hides the move-to-left control. */
+    oneWay?: boolean;
+    /** Enables client pagination for long lists. */
+    pagination?: boolean | {
+        pageSize?: number;
+    };
+    /** Localized labels for list chrome. */
+    locale?: {
+        /** Singular unit label in counts. */
+        itemUnit?: string;
+        /** Plural unit label in counts. */
+        itemsUnit?: string;
+        /** Default search placeholder. */
+        searchPlaceholder?: string;
+        /** Empty filtered list content. */
+        notFoundContent?: React__default.ReactNode;
+        /** Select-all checkbox label. */
+        selectAll?: string;
+        /** Deselect-all checkbox label. */
+        deselectAll?: string;
+    };
+    /** Root element class name. */
+    className?: string;
+    /** Root element inline style. */
+    style?: React__default.CSSProperties;
+    /** Renders semantic structure without Skygraph list styles. */
+    unstyled?: boolean;
+    /** Footer content for each panel [source, target]. */
+    footer?: [React__default.ReactNode, React__default.ReactNode] | ((props: {
+        direction: 'left' | 'right';
+    }) => React__default.ReactNode);
+    /** Custom operations area between the lists. */
+    operations?: [React__default.ReactNode, React__default.ReactNode];
+    /** Style for operations area. */
+    operationsStyle?: React__default.CSSProperties;
+    /** Enables drag-and-drop reorder within each list. */
+    sortable?: boolean;
+    /** Fires when items are reordered via drag in a list. */
+    onSort?: (direction: 'left' | 'right', keys: string[]) => void;
+    /** Shows item count per list. @default true */
+    showCount?: boolean;
+    /** Called when search value changes in either list. */
+    onSearch?: (direction: 'left' | 'right', value: string) => void;
+    /** Fixed height for the list body. */
+    listHeight?: number;
+    /** Custom class per list. */
+    listClassName?: string | ((direction: 'left' | 'right') => string);
+}
+/** Props for one column list inside `Transfer`. */
+interface TransferListProps {
+    /** Items shown in this column after filtering. */
+    items: TransferItem[];
+    /** Keys selected in this column. */
+    selectedKeys: string[];
+    /** Replaces selection for this column. */
+    onSelect: (keys: string[]) => void;
+    /** Column header title node. */
+    title?: React__default.ReactNode;
+    /** Custom item body render. */
+    render?: (item: TransferItem) => React__default.ReactNode;
+    /** Shows filter input above the list. */
+    showSearch?: boolean;
+    /** Custom search filter predicate. */
+    filterOption?: (inputValue: string, item: TransferItem) => boolean;
+    /** Search input placeholder. */
+    searchPlaceholder?: string;
+    /** @default true */
+    showSelectAll?: boolean;
+    /** Disables all interactions in the list. */
+    disabled?: boolean;
+    /** Client pagination config or boolean to use defaults. */
+    pagination?: boolean | {
+        pageSize?: number;
+    };
+    /** Resolved strings for counts and actions. */
+    locale: Required<TransferLocale>;
+    /** Which transfer side this list represents. */
+    direction: 'left' | 'right';
+    /** Unstyled list rendering. */
+    unstyled?: boolean;
+    /** Footer content. */
+    footer?: React__default.ReactNode;
+    /** Enables drag-and-drop reorder. */
+    sortable?: boolean;
+    /** Fires when items are reordered via drag. */
+    onSort?: (direction: 'left' | 'right', keys: string[]) => void;
+    /** Called when search changes. */
+    onSearch?: (direction: 'left' | 'right', value: string) => void;
+    /** Fixed height for the list body. */
+    listHeight?: number;
+    /** Custom class for the list. */
+    listClassName?: string | ((direction: 'left' | 'right') => string);
+}
+/** Optional strings merged into `DEFAULT_TRANSFER_LOCALE`. */
+interface TransferLocale {
+    /** Singular item unit label. */
+    itemUnit?: string;
+    /** Plural items unit label. */
+    itemsUnit?: string;
+    /** Search field placeholder. */
+    searchPlaceholder?: string;
+    /** Empty state when filter matches nothing. */
+    notFoundContent?: React__default.ReactNode;
+    /** Select-all control label. */
+    selectAll?: string;
+    /** Deselect-all control label. */
+    deselectAll?: string;
+}
+
+/**
+ * Two-column shuttle to move items between source and target key sets.
+ * Supports search, pagination, one-way mode, and unstyled rendering.
+ */
+declare function Transfer({ dataSource, targetKeys, onChange, selectedKeys: controlledSelectedKeys, onSelectChange, titles, render, showSearch, filterOption, searchPlaceholder, showSelectAll, disabled, oneWay, pagination, locale, className, style, unstyled, footer, operations, operationsStyle, sortable, onSort, onSearch, listHeight, listClassName, }: TransferProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Single-column checklist with optional search, select-all, pagination, drag-reorder, and footer.
+ * Used as the source and target panes of `Transfer`.
+ */
+declare function TransferList({ items, selectedKeys, onSelect, title, render, showSearch, filterOption, searchPlaceholder, showSelectAll, disabled, pagination, locale, direction, unstyled, footer, sortable, onSort, onSearch, listHeight, listClassName, }: TransferListProps): react_jsx_runtime.JSX.Element;
+
+/** One mention candidate in the suggestion list. */
+interface MentionOption {
+    /** Text inserted after the trigger prefix when the row is chosen. */
+    value: string;
+    /** Optional display string; defaults to value when omitted. */
+    label?: string;
+}
+/** Props for a textarea that shows mention suggestions after a prefix. */
+interface MentionsProps extends BaseComponentProps, InteractiveProps, SizableProps {
+    /** Controlled textarea value. */
+    value?: string;
+    /** Initial value when uncontrolled. */
+    defaultValue?: string;
+    /** Called when the textarea content changes. */
+    onChange?: (value: string) => void;
+    /** Character(s) that start a mention (e.g. @ or #). */
+    prefix?: string | string[];
+    /** Suggestion list filtered by the text after the active prefix. */
+    options?: MentionOption[];
+    /** Vertical position of the suggestion dropdown relative to the field. */
+    placement?: 'top' | 'bottom';
+    /** Called with the current query and matched prefix while typing a mention. */
+    onSearch?: (text: string, prefix: string) => void;
+    /** Called when a suggestion is inserted into the text. */
+    onSelect?: (option: MentionOption, prefix: string) => void;
+    /** Textarea placeholder. */
+    placeholder?: string;
+    /** Visible height of the textarea in rows. */
+    rows?: number;
+}
+/**
+ * Textarea with @-style mentions: shows a filtered list after a configured prefix.
+ * Supports keyboard navigation (arrows, Enter, Escape) when the list is open.
+ *
+ * @default defaultValue - `''`
+ * @default prefix - `'@'`
+ * @default options - `[]`
+ * @default placement - `'bottom'`
+ * @default rows - `3`
+ */
+declare function Mentions({ value, defaultValue, onChange, prefix: prefixConfig, options, placement, onSearch, onSelect, placeholder, rows, disabled: disabledProp, size: sizeProp, className, style, unstyled, }: MentionsProps): react_jsx_runtime.JSX.Element;
+
+/** Props for class-based enter/leave animation on a single child element. */
+interface TransitionProps {
+    /** When `true`, runs enter; when `false`, runs leave (and may unmount). */
+    visible: boolean;
+    /** Base class name prefix for default enter/leave classes (e.g. `sg-fade-enter-from`). @default 'sg-fade' */
+    name?: string;
+    /** Animation length in ms before idle phase and after callbacks. @default 200 */
+    duration?: number;
+    /** Custom initial class for the enter frame (with `-enter-active`). */
+    enterFrom?: string;
+    /** Custom final class for the enter-active frame. */
+    enterTo?: string;
+    /** Custom initial class for the leave frame (with `-leave-active`). */
+    leaveFrom?: string;
+    /** Custom final class for the leave-active frame. */
+    leaveTo?: string;
+    /** Fires once the enter transition timer completes. */
+    onAfterEnter?: () => void;
+    /** Fires once the leave transition timer completes. */
+    onAfterLeave?: () => void;
+    /** Single React element whose `className` will be merged with transition classes. */
+    children: React__default.ReactElement<{
+        className?: string;
+        ref?: React__default.Ref<HTMLElement>;
+    }>;
+    /** When `true`, removes the child from the tree after leave; when `false`, keeps it mounted. @default true */
+    unmountOnExit?: boolean;
+}
+/**
+ * Clones a single child and toggles CSS classes over `duration` when `visible` changes, optionally unmounting after leave.
+ */
+declare function Transition({ visible, name, duration, enterFrom, enterTo, leaveFrom, leaveTo, onAfterEnter, onAfterLeave, children, unmountOnExit, }: TransitionProps): React__default.ReactElement<{
+    className?: string;
+    ref?: React__default.Ref<HTMLElement>;
+}, string | React__default.JSXElementConstructor<any>> | null;
+
+/** Estimated password strength tier used for the strength meter. */
+type PasswordStrength = 'weak' | 'medium' | 'strong' | 'very-strong';
+/** Props for the password input with optional visibility toggle and strength UI. */
+interface InputPasswordProps extends BaseComponentProps, InteractiveProps, SizableProps {
+    /** Controlled password value. */
+    value?: string;
+    /** Initial value when uncontrolled. */
+    defaultValue?: string;
+    /** Input placeholder text. */
+    placeholder?: string;
+    /** Show a control to reveal or hide the password. @default true */
+    visibilityToggle?: boolean;
+    /** Show a strength bar and label when the field has text. @default false */
+    showStrength?: boolean;
+    /** Custom labels for each {@link PasswordStrength} tier (merged with defaults). */
+    strengthLabels?: Record<PasswordStrength, string>;
+    /** Called when the password text changes. */
+    onChange?: (value: string) => void;
+    /** Called when the input loses focus. */
+    onBlur?: () => void;
+    /** Called when the input gains focus. */
+    onFocus?: () => void;
+    /** Exposes validation state to assistive tech. */
+    'aria-invalid'?: boolean | 'false' | 'true' | 'grammar' | 'spelling';
+    /** Marks the field as required for assistive tech. */
+    'aria-required'?: boolean | 'false' | 'true';
+}
+/**
+ * Password field with optional show/hide toggle, loading state, and strength indicator.
+ */
+declare function InputPassword({ value, defaultValue, placeholder, visibilityToggle, showStrength, strengthLabels, size: sizeProp, disabled: disabledProp, loading, onChange, onBlur, onFocus, 'aria-invalid': ariaInvalid, 'aria-required': ariaRequired, className, style, unstyled, }: InputPasswordProps): react_jsx_runtime.JSX.Element;
+
+/** Props for the search field with optional clear and submit affordances. */
+interface SearchInputProps extends BaseComponentProps, InteractiveProps, SizableProps {
+    /** Controlled query string. */
+    value?: string;
+    /** Initial query when uncontrolled. */
+    defaultValue?: string;
+    /** Input placeholder. @default 'Search...' */
+    placeholder?: string;
+    /** Show a clear control when there is text and not loading. @default true */
+    allowClear?: boolean;
+    /** Add a submit button; use a string for custom button label. */
+    enterButton?: boolean | string;
+    /** Called when the user submits (Enter or button click). */
+    onSearch?: (value: string) => void;
+    /** Called when the query text changes. */
+    onChange?: (value: string) => void;
+    /** Called when the input loses focus. */
+    onBlur?: () => void;
+    /** Called when the input gains focus. */
+    onFocus?: () => void;
+}
+/**
+ * Search box with icon, optional clear button, loading spinner, and optional enter-to-search button.
+ */
+declare function SearchInput({ value, defaultValue, placeholder, allowClear, enterButton, size: sizeProp, disabled: disabledProp, loading, onSearch, onChange, onBlur, onFocus, className, style, unstyled, }: SearchInputProps): react_jsx_runtime.JSX.Element;
+
+/** Props for the token/tag chip input. */
+interface TagInputProps extends BaseComponentProps, InteractiveProps, SizableProps {
+    /** Controlled list of tags. */
+    value?: string[];
+    /** Initial tags when uncontrolled. @default [] */
+    defaultValue?: string[];
+    /** Shown when there are no tags. @default 'Add tag...' */
+    placeholder?: string;
+    /** Maximum number of tags allowed. */
+    maxTags?: number;
+    /** Allow the same tag text more than once. @default false */
+    allowDuplicates?: boolean;
+    /** Show remove controls on tags. @default true */
+    removable?: boolean;
+    /** Visual variant for tag chips. @default 'default' */
+    tagColor?: 'default' | 'success' | 'error' | 'warning' | 'processing';
+    /** Called when the tag list changes. */
+    onChange?: (tags: string[]) => void;
+    /** Called when the text field loses focus (pending text is committed as a tag). */
+    onBlur?: () => void;
+    /** Called when the text field gains focus. */
+    onFocus?: () => void;
+}
+/**
+ * Multi-value input where entries become removable tags (Enter/comma, paste, backspace to remove last).
+ */
+declare function TagInput({ value, defaultValue, placeholder, maxTags, allowDuplicates, removable, tagColor, size: sizeProp, disabled: disabledProp, loading, onChange, onBlur, onFocus, className, style, unstyled, }: TagInputProps): react_jsx_runtime.JSX.Element;
+
+/** Props for the multi-cell PIN or OTP code input. */
+interface PinInputProps extends BaseComponentProps, InteractiveProps, SizableProps {
+    /** Number of character cells. @default 6 */
+    length?: number;
+    /** Controlled combined string value (padded/truncated to `length`). */
+    value?: string;
+    /** Initial combined string when uncontrolled. @default '' */
+    defaultValue?: string;
+    /** Use password masking for each cell. @default false */
+    mask?: boolean;
+    /** Allowed character set per cell. @default 'numeric' */
+    type?: 'numeric' | 'alphanumeric';
+    /** Placeholder shown in empty styled cells. @default '○' */
+    placeholder?: string;
+    /** Focus the first cell on mount. @default false */
+    autoFocus?: boolean;
+    /** Fired once all cells are filled (non-space characters). */
+    onComplete?: (value: string) => void;
+    /** Fired on every change with the trimmed combined value. */
+    onChange?: (value: string) => void;
+    /** Accessible name for the input group. @default 'PIN input' */
+    'aria-label'?: string;
+}
+/**
+ * Fixed-length segmented input for PINs or one-time codes, with paste and arrow-key navigation.
+ */
+declare function PinInput({ length, value, defaultValue, mask, type, placeholder, autoFocus, size: sizeProp, disabled: disabledProp, loading, onComplete, onChange, className, style, unstyled, 'aria-label': ariaLabel, }: PinInputProps): react_jsx_runtime.JSX.Element;
+
+/** Props for the inline text editor (view vs edit modes). */
+interface InlineEditProps extends BaseComponentProps, InteractiveProps, SizableProps {
+    /** Controlled text value. */
+    value?: string;
+    /** Initial value when uncontrolled. @default '' */
+    defaultValue?: string;
+    /** Placeholder when the value is empty in view mode. @default 'Click to edit...' */
+    placeholder?: string;
+    /** Whether to show save/cancel controls in edit mode. @default true */
+    showButtons?: boolean;
+    /** Save draft when the input loses focus. @default true */
+    saveOnBlur?: boolean;
+    /** Save draft when Enter is pressed. @default true */
+    saveOnEnter?: boolean;
+    /** Called after a successful save with the new string. */
+    onSave?: (value: string) => void;
+    /** Called when editing is cancelled. */
+    onCancel?: () => void;
+    /** Custom view renderer; receives current value and a function to enter edit mode. */
+    renderView?: (value: string, startEditing: () => void) => React.ReactNode;
+}
+/**
+ * Inline field that switches between a read-only view and an editable input.
+ * Supports keyboard shortcuts (Enter to save, Escape to cancel).
+ */
+declare function InlineEdit({ value, defaultValue, placeholder, showButtons, saveOnBlur, saveOnEnter, size: sizeProp, disabled: disabledProp, loading, onSave, onCancel, renderView, className, style, unstyled, }: InlineEditProps): react_jsx_runtime.JSX.Element;
+
+/** Props for grouping an input with optional prefix and suffix addons. */
+interface InputGroupProps extends BaseComponentProps, SizableProps {
+    /** Tight visual spacing between addons and the control. @default true */
+    compact?: boolean;
+    /** Content rendered before the main child (e.g. icon or select). */
+    before?: React__default.ReactNode;
+    /** Content rendered after the main child. */
+    after?: React__default.ReactNode;
+    /** Primary control (typically an input). */
+    children: React__default.ReactNode;
+}
+/** Horizontally composes a control with optional leading and trailing slots. */
+declare function InputGroup({ compact, before, after, size: sizeProp, children, className, style, unstyled, }: InputGroupProps): react_jsx_runtime.JSX.Element;
+
+export { AreaChart, type AreaChartProps, type Assignment, AutoComplete, type AutoCompleteOption, type AutoCompleteProps, AutoFieldOption, Avatar, type AvatarProps, Badge, type BadgeProps, BarChart, type BarChartProps, type BaseChartProps, BaseComponentProps, Breadcrumb, type BreadcrumbItem, type BreadcrumbProps, Button, type ButtonProps, Calendar, type CalendarCellInfo, type CalendarEvent, type CalendarHeaderInfo, CalendarLocale, type CalendarProps, Carousel, type CarouselProps, Cascader, type CascaderOption, type CascaderProps, type ChartAction, type ChartActionContext, type ChartActionsProp, type ChartAnimation, ChartBrush, type ChartBrushConfig, type ChartBrushProps, type ChartBrushRange, type ChartCategory, type ChartContextMenuHandler, type ChartContextMenuPayload, ChartCrosshair, type ChartCrosshairPoint, type ChartCrosshairProps, ChartHoverToolbar, type ChartHoverToolbarProps, ChartLegend, type ChartLegendProps, type ChartRef, type ChartSeries, type ChartSeriesContextMenuHandler, type ChartSeriesContextMenuPayload, type ChartSize, type ChartValue, Checkbox, type CheckboxProps, Collapse, type CollapseItem, type CollapseProps, ColorPicker, type ColorPickerProps, ConfigProvider, type ConfigProviderProps, DEFAULT_CHART_ANIMATION_MS, DEFAULT_PALETTE, DEFAULT_PALETTE_ITEMS, Dashboard, type DashboardContextMenuHandler, DashboardEditor, type DashboardEditorProps, type DashboardLayoutChange, type DashboardLayoutPatch, type DashboardProps, type DashboardWidget, type DashboardWidgetContextMenuHandler, DatePicker, type DatePickerProps, type DatePreset, Descriptions, type DescriptionsItem, type DescriptionsProps, Diagram, type DiagramCanvasContextPoint, type EdgeAction as DiagramEdgeAction, type NodeAction as DiagramNodeAction, type DiagramNodeRenderer, type DiagramProps, type DiagramRef, type DiagramSelectionMode, type DownloadPngOptions, Drawer, type DrawerProps, Dropdown, type DropdownItem, type DropdownProps, type EditorAction, type EditorField, type EditorSchema, type EditorState, Empty, type EmptyProps, EventTimeline, type EventTimelineProps, FieldType, Gantt, type GanttProps, type GanttRange, type GanttResource, type GanttScale, type GanttTask, InlineEdit, type InlineEditProps, Input, InputGroup, type InputGroupProps, InputNumber, type InputNumberProps, InputPassword, type InputPasswordProps, type InputProps, InteractiveProps, JSONSchema, LineChart, type LineChartCrosshair, type LineChartProps, List, type ListItemMetaProps, type ListItemProps, type ListProps, type MentionOption, Mentions, type MentionsProps, Menu, type MenuItem, type MenuProps, Modal, type ModalProps, type NotificationConfig, NotificationContainer, type NotificationContainerProps, PALETTE_DATA_TYPE, Pagination, type PaginationProps, type PaletteItem, type PasswordStrength, type PickerMode, PieChart, type PieChartProps, type PieChartSlice, PinInput, type PinInputProps, type PngSize, Popconfirm, type PopconfirmProps, PrintOptions, PrintableProp, Progress, type ProgressProps, RadioGroup, type RadioGroupProps, type RadioOption, RangePicker, type RangePickerProps, Rate, type RateProps, type Resource, ResourceCalendar, type ResourceCalendarProps, Result, type ResultProps, type SchemaEditorStore, SchemaFormEditor, SchemaFormEditorCanvas, type SchemaFormEditorCanvasProps, SchemaFormEditorInspector, type SchemaFormEditorInspectorProps, SchemaFormEditorPalette, type SchemaFormEditorPaletteProps, type SchemaFormEditorProps, SchemaFormEditorSchemaView, type SchemaFormEditorSchemaViewProps, SearchInput, type SearchInputProps, Segmented, type SegmentedProps, Select, type SelectOption, type SelectProps, type SgConfig, SgLocale, type ShowTimeConfig, SizableProps, SizeType, Skeleton, type SkeletonProps, Slider, type SliderProps, Spin, type SpinProps, type StepItem, Steps, type StepsProps, Switch, type SwitchProps, type TabItem, Tabs, type TabsProps, Tag, TagInput, type TagInputProps, type TagProps, Textarea, type TextareaProps, TimePicker, type TimePickerProps, TimeRangePicker, type TimeRangePickerProps, Timeline, type TimelineEvent, type TimelineGroupBy, type TimelineItem, type TimelineOrientation, type TimelineProps, Tooltip, type TooltipProps, Transfer, type TransferItem, TransferList, type TransferListProps, type TransferProps, Transition, type TransitionProps, Upload, type UploadFile, type UploadProps, type UseGraphOptions, type UseGraphReturn, type UseSchemaEditorOptions, type WidgetAction, buildPageRule, buildPrintHtml, chartDataKey, colorForSeries, createEmptyEditorSchema, createFieldFromPaletteType, de_DE, defaultChartActions, downloadSvg, downloadSvgAsPng, editorSchemaToJsonSchema, en_US, es_ES, fr_FR, jsonSchemaToEditorSchema, makeChartContextMenuHandler, makeSeriesContextMenuHandler, measureSvg, notification, printElement, resolveBrushConfig, resolveChartActions, resolveChartAnimation, ru_RU, serializeSvg, triggerDownload, useChartSize, useComputed, useConfig, useGraph, useSchemaEditor, zh_CN };